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

{gea_program-0.56.0/gea_program.egg-info → gea_program-0.58.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.56.0
+Version: 0.58.0
 Summary: GEA-Program: downhole gauge monitoring - canonical measurement records, quality rules, drift evaluation with a re-fit change log, well-test validation, alarm management, model cards, store-and-forward, monthly SLA measurement, FAT/SAT protocols and a dashboard, generated from live objects in the client's reporting outline.
 Author: Daniel T. Murphy
 License: MPL-2.0
@@ -659,6 +659,17 @@ EIA) or a declared price, with the net revenue interest, severance tax and
 operating cost declared. A forecast is not a reserves report, and the page
 says so. The **Decline curves** tab, `gea decline`, `gea help decline`.
 
+### Hydraulics and ECD
+
+The pressures the mud makes while it circulates, from the six-speed
+viscometer (the API RP 13D power law: the pipe from 600/300, the annulus
+from 100/3): the standpipe pressure part by part - surface lines, string,
+motor and MWD, bit, annulus - the bit's hydraulics, the ECD at every depth
+against the pore pressure and fracture gradient, surge and swab and the
+fastest safe trip at each bit depth, and the standpipe pressure the rig
+measured against the model. The **Hydraulics & ECD** tab, `gea hydraulics`,
+`gea help hydraulics`.
+
 ### Torque and drag
 
 The hook load and torque the drill string should take at each bit depth, by
@@ -1291,6 +1302,19 @@ gea oidc --workspace C:\site --issuer https://login.microsoftonline.com/3f8b2c1d
 Or Administration -> **Company sign-in**. `gea help company-sign-in` has the
 Entra ID app registration step by step.
 
+### For an IT department
+
+`docs/IT_SECURITY.md` (`gea security` prints it from any installation)
+answers what a reviewer asks before installing: where the data is and every
+connection the program can make, the one port, HTTPS, company sign-in and
+roles, the audit log, the bill of materials (`gea sbom`), and how a kit is
+checked - the build's attestation
+(`gea-program-0.57.0-win64.zip` checked with
+`gh attestation verify gea-program-0.57.0-win64.zip -R Daniel8Murphy0007/GEA-Program`)
+and the file catalog beside the kit's folder, Authenticode-signed once the
+publisher's certificate is in place. `SECURITY.md` says how to report a
+vulnerability.
+
 ### Before a site goes live
 
 `deploy/README.md` is the checklist: HTTPS from the service itself (above),
@@ -1422,4 +1446,5 @@ https://pypi.org/project/gea-program/ after the first successful run.
 ## Licence
 
 Mozilla Public License 2.0 (MPL-2.0); see `LICENSE`. Every source file carries the MPL-2.0
-header (Exhibit A). Copyright (c) 2026 Daniel T. Murphy.
+header (Exhibit A). Copyright (c) 2026 Daniel T. Murphy. The signed kit, its updates and
+support are a subscription from ENRGYONE (`docs/commercial/COMMERCIAL.md`).

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

@@ -620,6 +620,17 @@ EIA) or a declared price, with the net revenue interest, severance tax and
 operating cost declared. A forecast is not a reserves report, and the page
 says so. The **Decline curves** tab, `gea decline`, `gea help decline`.
 
+### Hydraulics and ECD
+
+The pressures the mud makes while it circulates, from the six-speed
+viscometer (the API RP 13D power law: the pipe from 600/300, the annulus
+from 100/3): the standpipe pressure part by part - surface lines, string,
+motor and MWD, bit, annulus - the bit's hydraulics, the ECD at every depth
+against the pore pressure and fracture gradient, surge and swab and the
+fastest safe trip at each bit depth, and the standpipe pressure the rig
+measured against the model. The **Hydraulics & ECD** tab, `gea hydraulics`,
+`gea help hydraulics`.
+
 ### Torque and drag
 
 The hook load and torque the drill string should take at each bit depth, by
@@ -1252,6 +1263,19 @@ gea oidc --workspace C:\site --issuer https://login.microsoftonline.com/3f8b2c1d
 Or Administration -> **Company sign-in**. `gea help company-sign-in` has the
 Entra ID app registration step by step.
 
+### For an IT department
+
+`docs/IT_SECURITY.md` (`gea security` prints it from any installation)
+answers what a reviewer asks before installing: where the data is and every
+connection the program can make, the one port, HTTPS, company sign-in and
+roles, the audit log, the bill of materials (`gea sbom`), and how a kit is
+checked - the build's attestation
+(`gea-program-0.57.0-win64.zip` checked with
+`gh attestation verify gea-program-0.57.0-win64.zip -R Daniel8Murphy0007/GEA-Program`)
+and the file catalog beside the kit's folder, Authenticode-signed once the
+publisher's certificate is in place. `SECURITY.md` says how to report a
+vulnerability.
+
 ### Before a site goes live
 
 `deploy/README.md` is the checklist: HTTPS from the service itself (above),
@@ -1383,4 +1407,5 @@ https://pypi.org/project/gea-program/ after the first successful run.
 ## Licence
 
 Mozilla Public License 2.0 (MPL-2.0); see `LICENSE`. Every source file carries the MPL-2.0
-header (Exhibit A). Copyright (c) 2026 Daniel T. Murphy.
+header (Exhibit A). Copyright (c) 2026 Daniel T. Murphy. The signed kit, its updates and
+support are a subscription from ENRGYONE (`docs/commercial/COMMERCIAL.md`).

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

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

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

@@ -67,7 +67,16 @@ def _build_config(a):
     return SimulatorConfig(**kw)
 
 
+# the front door's own commands (gea.cli), reached the same way through `python -m gea` - the kit's gea.cmd and
+# gea wrapper run `python -m gea`, and before v0.57 `gea guide`, `gea help` and the rest answered "invalid choice"
+FRONT_ONLY = ('quickstart', 'guide', 'security', 'docs', 'gui', 'help')
+
+
 def main(argv=None) -> int:
+    _argv = list(sys.argv[1:] if argv is None else argv)
+    if _argv and _argv[0] in FRONT_ONLY:
+        from .cli import main as _front
+        return _front(_argv)
     ap = argparse.ArgumentParser(prog="gea",
                                  description="GEA Downhole Simulator - headless CLI")
     sub = ap.add_subparsers(dest="cmd", required=True)
@@ -637,6 +646,24 @@ def main(argv=None) -> int:
     p_dc.add_argument("--actor", type=str, default="cli")
     p_dc.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)
+    p_hy.add_argument("--example", action="store_true", help="the worked example (Volve 15/9-F-10 with an example mud, string and hole)")
+    p_hy.add_argument("--string", type=str, default=None, help="sections from the bit up: 'BHA:350:6.75:2.875; drill pipe::5:4.276' (what:length_ft:od_in:id_in)")
+    p_hy.add_argument("--hole", type=str, default=None, help="sections from the surface down: '9-5/8 casing:3500:8.681; open hole::8.75' (what:bottom_md_ft:id_in)")
+    p_hy.add_argument("--fann", type=str, default=None, help="the viscometer dial: '600=60 300=38 200=30 100=21 6=7 3=6'")
+    p_hy.add_argument("--nozzles", type=str, default=None, help="nozzle sizes in 32nds of an inch: '14 14 14 14 14'")
+    for k_, h_ in (("mw", "mud weight, ppg"), ("flow", "pump rate, gal/min"), ("bit", "bit diameter, in"), ("surface", "surface lines' pressure loss, psi"),
+                   ("surface-ref", "the rate (gal/min) the surface loss was declared at"), ("tools", "motor and MWD pressure drop, psi"),
+                   ("trip", "average stand speed tripping, ft/min"), ("pp", "a pore pressure for the hole when the Pore pressure tab has none, ppg"),
+                   ("fg", "a fracture gradient for the hole when the Pore pressure tab has none, ppg")):
+        p_hy.add_argument("--" + k_, type=str, default=None, help=h_)
+    p_hy.add_argument("--source", type=str, default="", help="where the mud, string and hole figures came from")
+    p_hy.add_argument("--write", action="store_true")
+    p_hy.add_argument("--actor", type=str, default="cli")
+    p_hy.add_argument("--json", action="store_true")
+
     p_td = sub.add_parser("torque-drag", help="the hook load and torque the string should take at each bit depth (soft-string model), the broomstick, and the friction factors that fit the rig's own trips")
     p_td.add_argument("--workspace", type=str, default=None)
     p_td.add_argument("--well", type=str, default=None)
@@ -2568,6 +2595,46 @@ 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 == "hydraulics":
+        import json as _json
+        from . import hydraulics as _HYD
+        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_ = {"mw": "mw_ppg", "flow": "flow_gpm", "bit": "bit_in", "surface": "surface_psi", "surface_ref": "surface_ref_gpm", "tools": "tools_psi",
+                     "trip": "trip_ft_min", "pp": "pp_ppg", "fg": "fg_ppg"}
+            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 any(x is not None for x in (a.string, a.hole, a.fann, a.nozzles))):
+                if not a.well:
+                    raise ValueError("--well is needed")
+                fann_ = None
+                if a.fann is not None:
+                    fann_ = {}
+                    for p_ in a.fann.replace(",", " ").split():
+                        k_, _, v_ = p_.partition("=")
+                        if not v_:
+                            raise ValueError(f"--fann takes SPEED=DIAL pairs, e.g. 600=60 300=38, not {p_!r}")
+                        fann_[k_.strip()] = v_.strip()
+                c_ = _HYD.set_well(ws, a.actor, a.well, a.source, a.string, a.hole, fann_, a.nozzles, **vals_)
+                print(f"{a.well}: mud {c_['mw_ppg']:g} ppg, {c_['flow_gpm']:g} gpm; string {len(c_.get('string') or [])} section(s), hole {len(c_.get('hole') or [])} section(s); "
+                      f"viscometer {' '.join(f'{k}={v:g}' for k, v in (c_.get('fann') or {}).items()) or 'not declared'}")
+                return 0
+            if a.write:
+                if ws is None:
+                    raise ValueError("--write needs --workspace")
+                r_ = _HYD.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 = _HYD.page(ws, scene, a.well)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"hydraulics: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _HYD.text(r))
+        return 0
     elif a.cmd == "torque-drag":
         import json as _json
         from . import torque_drag as _TND

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

@@ -12660,6 +12660,348 @@ def section_cy_company_sign_in(tmp: str) -> None:
        "the help page with the Entra ID steps" + (f" - failed: {failed4}" if failed4 else ""))
 
 
+def section_cz_it_review(tmp: str) -> None:
+    """Section CZ - what an IT department asks: the security overview ships with the program and agrees with the
+    code it describes (the rounds, the sessions, the lock, the port, TLS, every host the program can reach); `gea
+    security`, `gea guide` and `gea help` answer through `python -m gea` as the kit's launcher runs it; in a checkout,
+    the kit tools zip the kit again with its catalog beside it and tell the site how to check it, and the build
+    workflow attests both kits and signs the catalog only when a certificate is configured."""
+    import importlib.util
+    import json as _json
+    import subprocess as _sp
+    import urllib.parse as _up
+    import zipfile as _zf
+    from . import doctor as DR
+    from . import elevation as EL
+    from . import helplib as H
+    from . import seismic_watch as SW
+    from . import service as SVC
+    from . import tls as TLS
+    pkg = Path(__file__).parent
+    checkout = (pkg.parent / "pyproject.toml").exists() and (pkg.parent / "tools" / "build_installer.py").exists()
+
+    # -- CZ1 the overview, and the code it describes -------------------------------------------------------------------
+    text = H.security_text() or ""
+    docs_copy = pkg.parent / "docs" / "IT_SECURITY.md"
+    same = (not docs_copy.exists()) or docs_copy.read_text(encoding="utf-8") == text
+    flat = " ".join(text.split())
+    with open(Path(pkg, "reference", "eia_prices.provenance.json"), encoding="utf-8") as f:
+        eia_hosts = {_up.urlsplit(s["refresh_url"]).hostname for s in _json.load(f)["series"].values() if s.get("refresh_url")}
+    doctor_src = Path(DR.__file__).read_text(encoding="utf-8")
+    hosts = {_up.urlsplit(EL.EPQS_URL).hostname, _up.urlsplit(SW.QUERY_URL).hostname, _up.urlsplit(SW.FEED_URL).hostname, *eia_hosts}
+    hosts |= {"pypi.org"} if "https://pypi.org/pypi/gea-program/json" in doctor_src else {"(the update check moved)"}
+    facts = {
+        "rounds": f"{SVC.PBKDF2_ROUNDS:,}" in flat,
+        "sessions": f"{SVC.SESSION_HOURS} hours" in flat and "256-bit" in flat,
+        "lock": SVC.LOGIN_MAX_FAILURES == 5 and "five failures" in flat and f"{SVC.LOGIN_LOCK_S // 60} minutes" in flat,
+        "port": "TCP 8765" in flat and "8765" in Path(DR.__file__).read_text(encoding="utf-8"),
+        "tls": "TLS 1.2 minimum" in flat and f"last {TLS.EXPIRING_DAYS} days" in flat,
+        "hosts": all(f"`{h}`" in flat for h in hosts),
+        "no_telemetry": "No telemetry" in flat,
+    }
+    # Python 3.14's argparse formats every help string as the parser is built (help % params) and stops on a bare
+    # "%": v0.54.0's first ship stopped at its gate that way while 3.13 passed. The same check, on any Python.
+    import argparse as _ap
+    import contextlib as _cl
+    import io as _io
+    from . import __main__ as _M
+    bad_help = []
+    _orig_add, _orig_sub = _ap.ArgumentParser.add_argument, _ap._SubParsersAction.add_parser
+    _params = {k_: "x" for k_ in ("prog", "default", "dest", "type", "choices", "metavar", "required", "nargs", "const", "option_strings")}
+
+    def _fmt_ok(h):
+        try:
+            h % _params
+            return True
+        except (ValueError, TypeError, KeyError):
+            return False
+
+    def _add(self, *a_, **k_):
+        h_ = k_.get("help")
+        if isinstance(h_, str) and h_ != _ap.SUPPRESS and not _fmt_ok(h_):
+            bad_help.append(f"{self.prog} {'/'.join(a_)}")
+        return _orig_add(self, *a_, **k_)
+
+    def _sub(self, name, **k_):
+        h_ = k_.get("help")
+        if isinstance(h_, str) and not _fmt_ok(h_):
+            bad_help.append(f"gea {name}")
+        return _orig_sub(self, name, **k_)
+    _ap.ArgumentParser.add_argument, _ap._SubParsersAction.add_parser = _add, _sub
+    try:
+        with _cl.redirect_stdout(_io.StringIO()), _cl.redirect_stderr(_io.StringIO()):
+            try:
+                _M.main(["wells"])
+            except SystemExit:
+                pass
+    finally:
+        _ap.ArgumentParser.add_argument, _ap._SubParsersAction.add_parser = _orig_add, _orig_sub
+    facts["help_strings"] = not bad_help
+    r_sec = _sp.run([sys.executable, "-m", "gea", "security"], capture_output=True, text=True, encoding="utf-8", errors="replace")
+    r_guide = _sp.run([sys.executable, "-m", "gea", "guide"], capture_output=True, text=True, encoding="utf-8", errors="replace")
+    r_help = _sp.run([sys.executable, "-m", "gea", "help", "https"], capture_output=True, text=True, encoding="utf-8", errors="replace")
+    bad = [k for k, v in facts.items() if not v]
+    ok(text.startswith("# GEA-Program for an IT department") and same and not bad
+       and r_sec.returncode == 0 and "GEA-Program for an IT department" in r_sec.stdout
+       and r_guide.returncode == 0 and "HOW TO TEST GEA" in r_guide.stdout and r_help.returncode == 0 and "**The command**" in r_help.stdout,
+       "CZ1 the security overview ships in the package (identical to docs/IT_SECURITY.md) and agrees with the code: the password hashing rounds, the "
+       "session length and token size, the sign-in lock, the one port, the TLS floor and the expiry warning, every host the program can reach "
+       "(ComCat, the elevation service, the price series, PyPI); `python -m gea security`, `guide` and `help` answer as the kit's own launcher "
+       "runs them; every option's help text formats the way Python 3.14 checks it as the parser is built"
+       + (f" - disagrees: {bad}" if bad else "") + (f" - help texts: {bad_help}" if bad_help else ""))
+
+    # -- CZ2 the kit is zipped again with its catalog, and says how to check it ----------------------------------------------
+    if checkout:
+        spec = importlib.util.spec_from_file_location("cz_installer", str(pkg.parent / "tools" / "build_installer.py"))
+        bi = importlib.util.module_from_spec(spec); spec.loader.exec_module(bi)
+        kit = Path(tmp, "cz_kit", "gea-program-9.9.9-win64"); (kit / "python").mkdir(parents=True)
+        (kit / "MANIFEST.json").write_text("{}", encoding="utf-8"); (kit / "python" / "python.exe").write_bytes(b"MZ stand-in")
+        (kit / "SHA256SUMS.txt").write_text("x  MANIFEST.json\n", encoding="utf-8")
+        cat = Path(tmp, "cz_kit", "gea-program-9.9.9-win64.cat"); cat.write_bytes(b"0\x82 a catalog stand-in")
+        zp = bi.rezip(kit, [cat])
+        with _zf.ZipFile(zp) as z:
+            names = sorted(z.namelist())
+            cat_back = z.read("gea-program-9.9.9-win64.cat")
+        try:
+            bi.rezip(Path(tmp, "cz_kit"), [])
+            not_kit = "accepted"
+        except SystemExit as e:
+            not_kit = str(e)
+        readme = bi.README.format(version="9.9.9", target="Windows x64", pyline="p", install="i", start="s", verify="v", port="8765",
+                                  service="sv", stop="st", uninstall="u", workspace="w", check=bi.WIN_CHECK.format(version="9.9.9"))
+        build_src = (pkg.parent / "tools" / "build_installer.py").read_text(encoding="utf-8")
+        c2 = {
+            "rezip": names == ["gea-program-9.9.9-win64.cat", "gea-program-9.9.9-win64/MANIFEST.json", "gea-program-9.9.9-win64/SHA256SUMS.txt",
+                               "gea-program-9.9.9-win64/python/python.exe"] and cat_back == cat.read_bytes() and "not a kit folder" in not_kit,
+            "readme": all(x in readme for x in ("gh attestation verify gea-program-9.9.9-win64.zip -R Daniel8Murphy0007/GEA-Program",
+                                                "Test-FileCatalog -CatalogFilePath .\\gea-program-9.9.9-win64.cat -Path .\\gea-program-9.9.9-win64",
+                                                "Get-AuthenticodeSignature", "IT_SECURITY.md", "gea help https"))
+                      and "368 checks" not in readme and "behind the site's TLS proxy" not in readme,
+            "ships_overview": "docs' / 'IT_SECURITY.md'" in build_src and "kit / 'IT_SECURITY.md'" in build_src,
+        }
+        where = "the checkout's kit tools"
+    else:
+        c2 = {"installed": bool(H.security_text())}
+        where = "an installed copy: the kit tools are checked in the checkout"
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       f"CZ2 ({where}) the kit is zipped again from its folder with its file catalog beside the folder, every file kept; a folder that is not a kit "
+       "is refused; the kit's README tells the site how to check the build's attestation and every file against the catalog and its signature, "
+       "and carries the IT overview" + (f" - failed: {failed2}" if failed2 else ""))
+
+    # -- CZ3 the build workflow: attested, signed only with a certificate, never signed in name only ----------------------------
+    wf = pkg.parent / ".github" / "workflows" / "build-installer.yml"
+    if wf.exists():
+        y = wf.read_text(encoding="utf-8")
+        win = y[y.index("windows-kit:"):y.index("linux-kit:")]
+        lin = y[y.index("linux-kit:"):]
+        order = [win.index(s) for s in ("New-FileCatalog", "azure/artifact-signing-action", "signtool", "Test-FileCatalog", "--rezip", "call install.cmd",
+                                        "attest-build-provenance", "attach-kit.sh")]
+        c3 = {
+            "permissions": "id-token: write" in y and "attestations: write" in y and "contents: write" in y,
+            "attested": "actions/attest-build-provenance" in win and "actions/attest-build-provenance" in lin
+                        and "subject-path: dist/gea-program-*-win64.zip" in win and "subject-path: dist/gea-program-*-linux-*.zip" in lin,
+            "conditional": "if: env.ARTIFACT_SIGNING_ACCOUNT != ''" in win and "if: env.ARTIFACT_SIGNING_ACCOUNT == '' && env.SIGNING_PFX_BASE64 != ''" in win
+                           and "secrets.ARTIFACT_SIGNING_ACCOUNT" in win and "secrets.SIGNING_PFX_BASE64" in win,
+            "checked": "-CatalogVersion 2.0" in win and "throw 'the catalog does not match the kit'" in win
+                       and "throw 'a certificate is configured but the catalog is not validly signed'" in win and "ships unsigned" in win
+                       and "Remove-Item $pfx" in win and "/tr http://timestamp" in win and "timestamp-rfc3161" in win,
+            "order": order == sorted(order),
+            "policy": (pkg.parent / "SECURITY.md").exists() and "Report a vulnerability" in " ".join((pkg.parent / "SECURITY.md").read_text(encoding="utf-8").split()),
+        }
+        where3 = "the checkout's workflow"
+    else:
+        c3 = {"installed": True}
+        where3 = "an installed copy: the workflow is checked in the checkout"
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       f"CZ3 ({where3}) both kits are attested by the build that made them; the Windows kit's file catalog is made, signed by Azure Artifact "
+       "Signing or a PFX only when its secrets are configured (timestamped; the PFX removed), checked against the kit - a mismatch, or a "
+       "configured certificate that did not sign, stops the build - then zipped beside the kit before the kit is installed and its gate run; "
+       "SECURITY.md says how to report a vulnerability" + (f" - failed: {failed3}" if failed3 else ""))
+
+
+def section_da_hydraulics(tmp: str) -> None:
+    """Section DA - hydraulics and ECD: the power law's losses against their closed forms (Hagen-Poiseuille, the slot,
+    Blasius) and API RP 13D's field-unit forms, the bit against its classic formula; a record whose standpipe pressure is
+    the model's plus a known amount, read back; the worked example's ECD against its window, surge and swab; the API, the
+    CLI, the report, the dossier, the tab and the help."""
+    import http.cookiejar
+    import math as _m
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import zipfile as _zf
+    from . import __version__ as _ver
+    from . import dossier as DZ
+    from . import helplib as H
+    from . import hydraulics as HY
+    from . import well3d as W
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "hydraulics"); d.mkdir()
+
+    # -- DA1 by hand --------------------------------------------------------------------------------------------------------
+    mu, q = 0.03, 50.0
+    lp = HY.pipe_loss(q, 4.0, 1000.0, 8.33, 1.0, mu)
+    Q, D = q * HY.GPM, 4.0 * HY.IN
+    V = Q / (_m.pi * D * D / 4.0)
+    hp = 32.0 * mu * V * 1000.0 * HY.FT / D ** 2 / HY.PSI
+    la = HY.annulus_loss(q, 8.5, 5.0, 1000.0, 8.33, 1.0, mu)
+    Va = q * HY.GPM / (_m.pi * ((8.5 * HY.IN) ** 2 - (5.0 * HY.IN) ** 2) / 4.0)
+    slot = 48.0 * mu * Va * 1000.0 * HY.FT / (3.5 * HY.IN) ** 2 / HY.PSI
+    f_t = HY.friction(1e5, 1.0, 16.0)[0]
+    rh = HY.rheology({"600": 56, "300": 36, "200": 28, "100": 20, "6": 6, "3": 5})
+    n, K = rh["n_pipe"], rh["K_pipe"]
+    api = HY.pipe_loss(550.0, 4.276, 1000.0, 10.5, n, K)
+    Vf = 24.51 * 550.0 / 4.276 ** 2                                   # ft/min
+    mu_api = 100.0 * (5.11 * 56 / 1022 ** n) * (1.6 * Vf / 4.276) ** (n - 1) * ((3 * n + 1) / (4 * n)) ** n
+    re_api = 15.467 * Vf * 4.276 * 10.5 / mu_api
+    dp_api = 1.076 * 10.5 * Vf ** 2 * api["f"] / 1e5 / 4.276 * 1000.0
+    bt = HY.bit(550.0, 10.5, [13] * 6, 8.5)
+    refused = []
+    for bad in ({"600": 56}, {"600": 30, "300": 36}, {"600": 56, "300": 36, "450": 40}, {"600": 400, "300": 36}):
+        try:
+            HY.rheology(bad); refused.append(False)
+        except ValueError:
+            refused.append(True)
+    for fn, arg in ((HY.check_string, [{"what": "x", "length_ft": 100, "od_in": 5, "id_in": 6}]), (HY.check_hole, [{"what": "a", "bottom_md_ft": 1000, "id_in": 8},
+                                                                                                                       {"what": "b", "bottom_md_ft": 500, "id_in": 8}, {"what": "c", "id_in": 8}]),
+                    (HY.parse_sections, "BHA:300:6.75"), (HY.annulus_loss, None)):
+        try:
+            fn(arg, "string") if fn is HY.parse_sections else (HY.annulus_loss(500, 5.0, 6.0, 100, 10, 0.5, 0.5) if fn is HY.annulus_loss else fn(arg))
+            refused.append(False)
+        except ValueError:
+            refused.append(True)
+    c1 = {
+        "newtonian": abs(lp["psi"] / hp - 1) < 1e-4 and lp["regime"] == "laminar" and abs(la["psi"] / slot - 1) < 1e-9 and abs(f_t / (0.0791 / 1e5 ** 0.25) - 1) < 0.01,
+        "rheology": rh["pv_cp"] == 20 and rh["yp_lbf_100ft2"] == 16 and abs(rh["n_pipe"] - _m.log2(56 / 36)) < 1e-4 and abs(rh["n_ann"] - _m.log(20 / 5) / _m.log(170.2 / 5.11)) < 1e-4
+                    and rh["tau0_lbf_100ft2"] == 4 and rh["annulus_from"] == "100 and 3 rpm",
+        "api_forms": abs(api["v_ft_min"] / Vf - 1) < 1e-3 and abs(api["mu_cp"] / mu_api - 1) < 1e-3 and abs(api["re"] / re_api - 1) < 2e-3 and abs(api["psi"] / dp_api - 1) < 1e-3,
+        "bit": abs(bt["psi"] / (156.5 * 10.5 * 550.0 ** 2 / (6 * 13 ** 2) ** 2) - 1) < 1e-3 and abs(bt["tfa_in2"] - 6 * _m.pi / 4 * (13 / 32) ** 2) < 1e-3
+               and abs(bt["hhp"] - bt["psi"] * 550 / 1714) < 0.1,
+        "refused": all(refused) and len(refused) == 8,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "DA1 the losses by hand: a Newtonian fluid's laminar loss in a pipe is Hagen-Poiseuille's and in the annulus the slot's, exactly; its turbulent "
+       "friction factor Blasius's to 1 %; the viscometer's PV, YP, the pipe's n from 600/300 and the annulus's from 100/3; the velocity, effective "
+       "viscosity, Reynolds number and loss equal to API RP 13D's field-unit forms; the bit's loss the classic 156.5 rho Q^2 / (sum d^2)^2; readings "
+       "missing, falling or out of range, a bore wider than the pipe, a hole out of order, a short section and a pipe wider than its hole refused"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- DA2 a record made by the model, read back ---------------------------------------------------------------------------
+    f = HY.selftest_files(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    wid = ws.add_well_file(f["record"], display="HY-1", actor="tester")["id"]
+    ws.set_well(wid, surface={"lat": 31.42, "lon": -104.10, "datum": "NAD83", "elevation": {"ft": 3000.0, "datum": "KB", "source": "test plat"}}, actor="tester")
+    no_survey = HY.page(ws, "workspace", wid)["detail"]
+    W.attach_trajectory(ws, wid, "s.csv", Path(f["survey"]).read_bytes(), "tester", "true", "ft", None, None, None, "test survey")
+    no_decl = HY.page(ws, "workspace", wid)["detail"]
+    c = f["config"]
+    HY.set_well(ws, "tester", wid, "mud report (test)", string=c["string"], hole=c["hole"], fann=c["fann"], nozzles_32=c["nozzles_32"], mw_ppg=c["mw_ppg"],
+                flow_gpm=500, bit_in=8.75, tools_psi=400, pp_ppg=9.5, fg_ppg=14.5)
+    r = HY.page(ws, "workspace", wid)["result"]
+    rc = r["record"]
+    cc = r["circulating"]
+    c2 = {
+        "needs": "survey" in no_survey and "string" in no_decl and "viscometer" in no_decl,
+        "record": rc and rc["bins"] >= 20 and abs(rc["median_difference_psi"] - f["offset_psi"]) <= 10.0 and rc["spread_psi"] < 30.0,
+        "parts": abs(sum(cc["parts"].values()) - cc["spp_psi"]) < 1.0 and cc["parts"]["tools"] == 400.0 and cc["parts"]["surface"] == 0.0,
+        "ecd": cc["ecd_bit_ppg"] > c["mw_ppg"] and all(e_ >= c["mw_ppg"] for e_ in r["ecd"]["ecd_ppg"])
+               and abs(cc["ecd_bit_ppg"] - (c["mw_ppg"] + cc["parts"]["annulus"] / (0.052 * cc["tvd_bit_ft"]))) < 0.002,
+        "window": r["window_how"].startswith("declared") and r["min_fg_margin"]["ppg"] == min(x for x in r["ecd"]["margin_fg_ppg"] if x is not None),
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "DA2 a drilling record made by the model - drilling from 4,000 to 10,000 ft at 500 gpm and circulating at 350 gpm, its standpipe pressure the "
+       "model's plus 120 psi and noise - read back while pumping: the median difference 120 psi to within 10 over 20 or more depth bins; the standpipe "
+       "pressure the sum of its parts; the ECD at the bit the mud weight plus the annular loss over 0.052 TVD; a well without a survey or its "
+       "declarations says what it needs" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- DA3 the worked example ----------------------------------------------------------------------------------------------
+    ex = HY.example()
+    t = ex["trips"]
+    s_hi = HY.surge_swab(ex["config"], ex["rheology"], ex["td_ft"], 180.0, lambda z: ex["tvd_td_ft"] * z / ex["td_ft"])
+    s_lo = HY.surge_swab(ex["config"], ex["rheology"], ex["td_ft"], 90.0, lambda z: ex["tvd_td_ft"] * z / ex["td_ft"])
+    rates = ex["by_rate"]
+    c3 = {
+        "example": ex["well"] == "15/9-F-10" and abs(ex["td_ft"] - 5300.07 / 0.3048) < 5.0 and "not from Volve" in ex["config"]["source"]
+                   and 2000 < ex["circulating"]["spp_psi"] < 5000 and ex["circulating"]["ecd_bit_ppg"] > ex["config"]["mw_ppg"],
+        "rates": all(b["spp_psi"] > a["spp_psi"] and b["ecd_bit_ppg"] >= a["ecd_bit_ppg"] for a, b in zip(rates, rates[1:])),
+        "surge": all(su > ex["config"]["mw_ppg"] > sw for su, sw in zip(t["surge_ppg"], t["swab_ppg"])) and s_hi["psi"] > s_lo["psi"] > 0,
+        "speeds": all(v is not None and v > 0 for v in t["run_max_ft_min"] + t["pull_max_ft_min"])
+                  and HY.surge_swab(ex["config"], ex["rheology"], ex["td_ft"], t["run_max_ft_min"][-1], lambda z: ex["tvd_td_ft"] * z / ex["td_ft"])["surge_ppg"] <= 14.0 + 0.02,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "DA3 the worked example, Volve 15/9-F-10's survey to its 5,300 m TD with a mud, string and hole declared for the example: the standpipe pressure "
+       "and the ECD rising with the rate; surge above and swab below the mud weight at every bit depth, more at a faster trip; the fastest run keeping "
+       "the surge within the declared fracture gradient" + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- DA4 the API, the CLI, the report, the dossier, the tab and the help -------------------------------------------------
+    Users(str(Path(wsp, "users.json"))).add("v", "viewer-pass-1", "viewer"); 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("/")
+
+    def opener(name, pw_):
+        o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+        rq = urllib.request.Request(base_url + "/api/login", method="POST", data=json.dumps({"name": name, "password": pw_}).encode())
+        rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1"); o.open(rq, timeout=30)
+        return o
+
+    def call(o, 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))
+        if method == "POST":
+            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:
+        V_, O_ = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_vg, vg = call(V_, "GET", "/api/hydraulics?well=" + wid)
+        s_ve, ve = call(V_, "GET", "/api/hydraulics?scene=example")
+        s_vs, _ = call(V_, "POST", "/api/hydraulics/settings", {"well_id": wid, "mw_ppg": 11.2, "source": "x"})
+        s_os, os_ = call(O_, "POST", "/api/hydraulics/settings", {"well_id": wid, "mw_ppg": "11.2", "r600": "62", "r300": "40", "r100": "22", "r3": "6",
+                                                                  "nozzles_32": "13 13 13 13 13", "hole": "9-5/8 casing:3500:8.681; open hole::8.75", "source": "mud report (test)"})
+        s_bf, _ = call(O_, "POST", "/api/hydraulics/settings", {"well_id": wid, "r600": "30", "r300": "40", "source": "x"})
+        s_bh, _ = call(O_, "POST", "/api/hydraulics/settings", {"well_id": wid, "flow_gpm": 9000, "source": "x"})
+        s_ns, _ = call(O_, "POST", "/api/hydraulics/settings", {"well_id": wid, "mw_ppg": 12})
+        s_vw, _ = call(V_, "POST", "/api/hydraulics/write", {"well_id": wid})
+        s_ow, ow = call(O_, "POST", "/api/hydraulics/write", {"well_id": wid})
+    finally:
+        svc.stop()
+    cli_x = _sp.run([sys.executable, "-m", "gea", "hydraulics", "--example"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_s = _sp.run([sys.executable, "-m", "gea", "hydraulics", "--workspace", wsp, "--well", wid, "--flow", "450", "--fann", "600=60 300=38 100=21 3=6",
+                     "--source", "mud report (test)"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_b = _sp.run([sys.executable, "-m", "gea", "hydraulics", "--workspace", wsp, "--well", wid, "--fann", "600:60", "--source", "x"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_t = _sp.run([sys.executable, "-m", "gea", "hydraulics", "--workspace", wsp, "--well", wid], capture_output=True, text=True, cwd=str(pkg.parent))
+    dz = DZ.build(ws, "tester", _ver, None)
+    names = _zf.ZipFile(Path(ws.reports_dir, dz["path"])).namelist()
+    audit = Path(ws.audit_path).read_text(encoding="utf-8")
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c4 = {
+        "api": s_vg == 200 and vg["result"]["record"]["bins"] >= 20 and s_ve == 200 and ve["result"]["well"] == "15/9-F-10" and s_vs == 403 and s_os == 200
+               and os_["fann"] == {"600": 62.0, "300": 40.0, "100": 22.0, "3": 6.0} and os_["nozzles_32"] == [13.0] * 5 and os_["mw_ppg"] == 11.2
+               and s_bf == 400 and s_bh == 400 and s_ns == 400 and s_vw == 403 and s_ow == 200 and ow["report_id"].startswith("HYD-"),
+        "cli": cli_x.returncode == 0 and "standpipe" in cli_x.stdout and "ECD at the bit" in cli_x.stdout and cli_s.returncode == 0 and "450 gpm" in cli_s.stdout
+               and cli_b.returncode != 0 and "SPEED=DIAL" in (cli_b.stderr + cli_b.stdout) and cli_t.returncode == 0 and "against the record" in cli_t.stdout,
+        "report": PR_read_ok(Path(ws.reports_dir, "wells", wid, "hydraulics.pdf")) and all(x in audit for x in ("hydraulics.declare", "report.hydraulics")),
+        "dossier": "declarations/drillstring/hydraulics.json" in names and f"results/hydraulics/{wid}.json" in names,
+        "page": all(x in page_src for x in ("VIEWS.hydraulics", "['#/hydraulics', 'Hydraulics & ECD']", "/api/hydraulics/settings", "hyChart", "hySppChart")),
+        "help": not H.check("hydraulics") and H.VIEW_TOPIC.get("hydraulics") == "hydraulics",
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "DA4 the tab's data for a viewer (the well, the worked example); the declarations by an operator only, with a source, readings and rates in "
+       "range; `gea hydraulics` prints the example and a well and declares the viscometer as SPEED=DIAL; the report with its PDF, audited; the "
+       "signed dossier carries the declarations and the result; the tab and the help page"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+
 def PR_read_ok(path) -> bool:
     from . import pdf_report as PR
     try:
@@ -12774,6 +13116,8 @@ def main() -> int:
         section_cw_decline(tmp)
         section_cx_https(tmp)
         section_cy_company_sign_in(tmp)
+        section_cz_it_review(tmp)
+        section_da_hydraulics(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.56.0 → gea_program-0.58.0}/gea/cli.py

@@ -10,6 +10,7 @@
     gea model-cards ...    gea store-forward ...  gea sla-report ...  gea fat-sat ...
     gea help [topic]                    the help library, by the job (gea help drift); same text as the dashboard's panels
     gea guide                           the click-by-click tester guide
+    gea security                        what an IT department asks before installing, answered (docs/IT_SECURITY.md)
     gea docs                            where the catalogue and the reports live on this machine
     gea gui                             the desktop window (desktop extra)
     gea accept                          the product gate
@@ -23,7 +24,7 @@ import os
 import sys
 from pathlib import Path
 
-FRONT = {'quickstart', 'survey', 'guide', 'docs', 'gui', 'help', '-h', '--help'}
+FRONT = {'quickstart', 'survey', 'guide', 'security', 'docs', 'gui', 'help', '-h', '--help'}
 
 
 def _pkg_root() -> Path:
@@ -62,6 +63,16 @@ def cmd_guide(_argv) -> int:
     return 0
 
 
+def cmd_security(_argv) -> int:
+    from .helplib import security_text
+    text = security_text()                                # ships inside the package (gea/help/IT_SECURITY.md)
+    if text is None:
+        print('the security overview is missing from this installation; reinstall: python -m pip install --upgrade --force-reinstall "gea-program[live]"')
+        return 2
+    print(text)
+    return 0
+
+
 def cmd_help(argv) -> int:
     from .helplib import page, index_text, topics
     if not argv:
@@ -141,6 +152,8 @@ def main(argv=None) -> int:
             return cmd_survey(rest)
         if cmd == 'guide':
             return cmd_guide(rest)
+        if cmd == 'security':
+            return cmd_security(rest)
         if cmd == 'docs':
             return cmd_docs(rest)
         if cmd == 'gui':

{gea_program-0.56.0 → gea_program-0.58.0}/gea/dossier.py

@@ -278,7 +278,7 @@ def _gather(ws, well_id: Optional[str]) -> Dict[str, List[tuple]]:
                 ('economics', 'invoices', 'terms.json'), ('economics', 'invoices', 'files.json'), ('drillstring', 'rig_time.json'),
                 ('drillstring', 'casing.json'), ('wellpath', 'collision.json'), ('wellpath', 'survey_program.json'),
                 ('completion', 'frac', 'stages.json'), ('completion', 'frac', 'settings.json'), ('geomech', 'pore_pressure.json'),
-                ('drillstring', 'torque_drag.json'), ('economics', 'production', 'production.json')):
+                ('drillstring', 'torque_drag.json'), ('economics', 'production', 'production.json'), ('drillstring', 'hydraulics.json')):
         p = os.path.join(ws.path, *rel)
         if os.path.isfile(p):
             out_list.append((p, 'declarations/' + '/'.join(rel)))
@@ -351,6 +351,17 @@ def _results(ws, well_id: Optional[str]) -> List[tuple]:
                                                                           indent=1, sort_keys=True, default=str).encode('utf-8')))
     except Exception as e:
         out.append(('results/decline_not_run.txt', f'the decline curves did not run: {type(e).__name__}: {e}\n'.encode('utf-8')))
+    try:
+        from . import hydraulics as HYD
+        declared = (HYD._load(ws).get('wells') or {})
+        for wid in wells:
+            if wid in declared:
+                r = HYD.page(ws, 'workspace', wid).get('result')
+                if r:
+                    out.append((f'results/hydraulics/{wid}.json', json.dumps({k: v for k, v in r.items() if k != 'measured'}, indent=1, sort_keys=True,
+                                                                              default=str).encode('utf-8')))
+    except Exception as e:
+        out.append(('results/hydraulics_not_run.txt', f'the hydraulics model did not run: {type(e).__name__}: {e}\n'.encode('utf-8')))
     try:
         from . import torque_drag as TND
         declared = (TND._load(ws).get('wells') or {})