gea-program 0.1.0__py3-none-any.whl

gea/inverse_engine.py

@@ -0,0 +1,215 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+"""inverse_engine - Part 3 of the subsurface surveying tool: THE
+INVERSE ENGINE (measurement -> strata, with uncertainty).
+
+v1.77.0. The direction the whole mission points: read the ground. This first
+inverse composes the two layers already built and validated:
+
+    measured borehole gravity            (the catalogue's own archives)
+        -> implied density column        (K2 forward model inverted;
+                                          GEA constants g_U, G_U, R_U)
+        -> posterior strata properties   (strata-join conditional priors:
+                                          the library's OWN joint
+                                          distributions, P(Vp | rho), ...)
+        -> layer-boundary candidates     (density-step detector, disclosed
+                                          threshold)
+
+EVERY estimate carries its full chain: which constants, which prior well,
+how many co-located bins support it, whether the query extrapolates beyond
+the prior's observed range, and the CROSS-SITE TRANSFER assumption stated
+in words (a prior learned in oceanic basalt applied to continental gneiss
+is an assumption, not a fact - the engine says so on every estimate).
+
+WHAT THIS ENGINE REFUSES TO DO
+    - It never averages archives into a 'truth'.
+    - It never returns an estimate without n, spread, and support.
+    - It never hides that today's priors come from ONE well family; the
+      posterior is exactly as provincial as the library, no more.
+
+FALSIFIABILITY
+    Run on the KTB gravity column with the 504B prior, the engine PREDICTS
+    the KTB sonic column (Vp vs depth) - a log that exists in the GFZ
+    archives but is NOT yet in this catalogue. Ingesting it tests the
+    entire chain end-to-end. The prediction is emitted, labeled
+    PREDICTION_AWAITING_DATA, and pinned; it can be wrong, which is the
+    point.
+"""
+
+from __future__ import annotations
+
+import statistics
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from .forward_model import implied_density_gcc
+from .profile_catalog import CATALOG
+from . import strata_join as SJ
+
+PRIOR_FAMILIES = {
+    # v1.79.0 (the lesson of the first scored prediction): priors are chosen
+    # by GEOLOGICAL FAMILY, not by whatever well the library learned first.
+    # 'oceanic_igneous' draws on the 504B joint tables (basalt flank);
+    # 'continental_crystalline' draws SITE-NATIVE pairs from the KTB
+    # composite-log excerpt (entry 52 - the very data that refuted the
+    # transferred prediction now supplies the corrected prior).
+    'oceanic_igneous': {
+        'kind': 'strata_join', 'source': '504b',
+        'note': 'joint tables learned in oceanic basalt (DSDP/ODP 504B)'},
+    'continental_crystalline': {
+        'kind': 'site_pairs', 'source': 'ktb_hb_complog_6020_excerpt',
+        'note': ('site-native rho-Vp pairs from the KTB composite excerpt; '
+                 'washout stations (RHOB <= 2.5 g/cc against enlarged '
+                 'caliper) excluded with the count disclosed - hole '
+                 'artifacts, not rock')},
+}
+
+WASHOUT_RHO_GCC = 2.5
+
+
+def _site_native_pairs(entry: str):
+    """Co-located (rho, Vp) pairs from a composite-log entry, washouts
+    excluded (disclosed). Returns (pairs, n_excluded)."""
+    st = CATALOG[entry].stream()
+    rb = [float(v) for v in st.channels['RHOB (g/cm3)'].values]
+    dt = [float(v) for v in st.channels['DTCO (us/m)'].values]
+    pairs = [(r, 1e6 / t) for r, t in zip(rb, dt) if r > WASHOUT_RHO_GCC and t > 0]
+    return pairs, sum(1 for r in rb if 0 < r <= WASHOUT_RHO_GCC)
+
+
+def _conditional_from_pairs(pairs, value: float, k: int = 7):
+    """k-nearest empirical conditional over raw co-located stations - same
+    honesty contract as the strata-join conditional (n, spread, support,
+    extrapolation flag; refuses when thin)."""
+    if len(pairs) < 8:
+        return {'status': 'REFUSED_THIN_DATA', 'n': len(pairs), 'min_n': 8}
+    lo = min(g for g, _ in pairs)
+    hi = max(g for g, _ in pairs)
+    near = sorted(pairs, key=lambda p: abs(p[0] - value))[:max(int(k), 1)]
+    tv = [t for _, t in near]
+    est = sum(tv) / len(tv)
+    spread = (statistics.pstdev(tv) if len(tv) > 1 else 0.0)
+    return {'status': 'OK', 'estimate': est, 'std': spread, 'n': len(near),
+            'support': (min(g for g, _ in near), max(g for g, _ in near)),
+            'extrapolation': not (lo <= value <= hi)}
+
+
+CROSS_SITE_NOTE = ("cross-site transfer: prior learned at '%s' applied at "
+                   "'%s' - an assumption the engine discloses, not a fact")
+
+
+@dataclass
+class StrataEstimate:
+    """One inverted interval: what the ground implies, and how sure."""
+    depth_m: float
+    dz_m: float
+    implied_density_gcc: float
+    posteriors: Dict[str, Dict] = field(default_factory=dict)
+    chain: Dict[str, str] = field(default_factory=dict)
+
+
+def detect_boundaries(depths: List[float], implied_rho: List[float],
+                      k_sigma: float = 2.0) -> List[Dict]:
+    """Layer-boundary candidates: consecutive implied-density changes
+    exceeding k_sigma population sigmas (threshold disclosed in each hit).
+    Candidates, not verdicts - amplitude and depth reported, nothing
+    smoothed away."""
+    if len(implied_rho) < 3:
+        return []
+    steps = [implied_rho[i] - implied_rho[i - 1] for i in range(1, len(implied_rho))]
+    sd = statistics.pstdev(steps)
+    if sd == 0.0:
+        return []
+    return [{'depth_m': depths[i + 1], 'delta_rho_gcc': steps[i],
+             'n_sigma': abs(steps[i]) / sd, 'threshold_sigma': k_sigma}
+            for i in range(len(steps)) if abs(steps[i]) > k_sigma * sd]
+
+
+def invert_gravity_column(entry: str = 'ktb_hb_bhgm_density',
+                          prior_well: str = '504b',
+                          targets: tuple = ('vp', 'porosity'),
+                          rho_null_gcc: float = 0.5,
+                          k_sigma: float = 2.0,
+                          prior_family: str = None) -> Dict:
+    """The first full inversion: a measured gravity column becomes a strata
+    column with uncertainty. Null stations (archive density zeros) excluded
+    with the count disclosed; every posterior carries n/spread/support and
+    the extrapolation flag from the prior itself."""
+    fam = PRIOR_FAMILIES.get(prior_family) if prior_family else None
+    fam_pairs, fam_washouts = (None, 0)
+    if fam and fam['kind'] == 'site_pairs':
+        fam_pairs, fam_washouts = _site_native_pairs(fam['source'])
+    st = CATALOG[entry].stream()
+    z = [float(v) for v in st.index]
+    grav = [float(v) for v in st.channels['GRAV'].values]
+    rho_tool = [float(v) for v in st.channels['RHO'].values]
+    estimates: List[StrataEstimate] = []
+    excluded = 0
+    for i in range(1, len(z)):
+        dz = z[i] - z[i - 1]
+        if dz <= 0:
+            continue
+        if rho_tool[i] <= rho_null_gcc or rho_tool[i - 1] <= rho_null_gcc:
+            excluded += 1
+            continue
+        rho_imp = implied_density_gcc(grav[i] - grav[i - 1], dz)
+        if fam and fam['kind'] == 'site_pairs':
+            chain = {
+                'measurement': '%s GRAV interstation (mGal)' % entry,
+                'density_inversion': 'K2 GEA constants (forward_model)',
+                'prior': 'PRIOR_FAMILY %s: %s' % (prior_family, fam['note']),
+                'assumption': ('SITE-NATIVE prior (same borehole family) - '
+                               'in-sample at the excerpt window, disclosed; '
+                               '%d washout stations excluded' % fam_washouts),
+            }
+            est = StrataEstimate(depth_m=z[i], dz_m=dz,
+                                 implied_density_gcc=rho_imp, chain=chain)
+            est.posteriors['vp'] = _conditional_from_pairs(fam_pairs, rho_imp)
+            estimates.append(est)
+            continue
+        est = StrataEstimate(
+            depth_m=z[i], dz_m=dz, implied_density_gcc=rho_imp,
+            chain={
+                'measurement': '%s GRAV interstation (mGal)' % entry,
+                'density_inversion': 'K2 GEA constants (forward_model)',
+                'prior': 'strata_join joint table, well %s' % prior_well,
+                'assumption': CROSS_SITE_NOTE % (prior_well, entry),
+            })
+        for t in targets:
+            given = ('wet_bulk_density'
+                     if 'wet_bulk_density' in SJ.WELL_GROUPS[prior_well][1] else None)
+            if given is None or t not in SJ.WELL_GROUPS[prior_well][1]:
+                est.posteriors[t] = {'status': 'NO_PRIOR_CHANNEL'}
+                continue
+            est.posteriors[t] = SJ.conditional(prior_well, t, given, rho_imp)
+        estimates.append(est)
+
+    depths = [e.depth_m for e in estimates]
+    rhos = [e.implied_density_gcc for e in estimates]
+    boundaries = detect_boundaries(depths, rhos, k_sigma)
+    ok_vp = [e for e in estimates
+             if e.posteriors.get('vp', {}).get('status') == 'OK']
+    in_support = [e for e in ok_vp if not e.posteriors['vp']['extrapolation']]
+    prediction = None
+    if in_support:
+        vps = [e.posteriors['vp']['estimate'] for e in in_support]
+        prediction = {
+            'status': 'PREDICTION_AWAITING_DATA',
+            'predicted_property': 'Vp (m/s) column at %s' % entry,
+            'n_intervals_in_prior_support': len(in_support),
+            'vp_range_m_s': (min(vps), max(vps)),
+            'vp_mean_m_s': statistics.mean(vps),
+            'test': ('ingest the %s sonic log (exists in the source archive, '
+                     'not yet catalogued) and score these estimates - the '
+                     'chain is falsified if the measured column leaves the '
+                     'posterior spreads' % entry),
+        }
+    return {
+        'entry': entry, 'prior_well': prior_well,
+        'n_intervals': len(estimates), 'null_intervals_excluded': excluded,
+        'n_posterior_ok': len(ok_vp), 'n_in_prior_support': len(in_support),
+        'boundary_candidates': boundaries,
+        'falsifiable_prediction': prediction,
+        'estimates': estimates,
+    }

gea/matplotlib_demo.py

@@ -0,0 +1,85 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+"""matplotlib_demo — animated demo of the GEA Downhole Simulator.
+
+Template-faithful port (22Aug2026 thread, converged imperial version): a well
+schematic on the left (gauges labeled with live P/T), pressure and temperature
+strip charts on the right, FuncAnimation at 120 ms, CSV export on close.
+
+Run:  python -m gea.matplotlib_demo
+Needs a display (or a matplotlib backend that has one). The engine itself is
+headless — only this demo draws.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .downhole_engine import SimulatorConfig, DownholeEngine
+
+
+def run_demo():
+    import matplotlib.pyplot as plt
+    from matplotlib.animation import FuncAnimation
+
+    cfg = SimulatorConfig()
+    engine = DownholeEngine(cfg)
+
+    fig = plt.figure(figsize=(13, 8), facecolor="#0b1220")
+    gs = fig.add_gridspec(2, 2, width_ratios=[1, 2.2])
+    ax_w = fig.add_subplot(gs[:, 0], facecolor="#0b1220")
+    ax_p = fig.add_subplot(gs[0, 1], facecolor="#101a2e")
+    ax_t = fig.add_subplot(gs[1, 1], facecolor="#101a2e")
+
+    def draw_well():
+        ax_w.clear()
+        ax_w.set_facecolor("#0b1220")
+        ax_w.set_xlim(-1.6, 1.6)
+        ax_w.set_ylim(cfg.td_ft * 1.03, -600)
+        ax_w.set_xticks([])
+        ax_w.set_ylabel("Depth (ft)", color="#e0f2fe")
+        ax_w.tick_params(colors="#e0f2fe")
+        ax_w.plot([-0.28, -0.28], [0, cfg.td_ft], color="#475569", lw=3)
+        ax_w.plot([0.28, 0.28], [0, cfg.td_ft], color="#475569", lw=3)
+        ax_w.plot([-0.28, 0.28], [cfg.td_ft, cfg.td_ft], color="#475569", lw=3)
+        for i, s in enumerate(engine.sensors):
+            ax_w.plot(0, s.depth_ft, "o", ms=10, color="#22d3ee")
+            ax_w.text(0.45, s.depth_ft,
+                      f"{s.name}  {engine.P[i]:.0f} psi  {engine.T[i]:.1f}\N{DEGREE SIGN}F",
+                      fontsize=8, va="center", color="#e0f2fe")
+
+    def update(_frame):
+        engine.step()
+        draw_well()
+        t_hist = engine.history_t
+        for ax, series_hist, label in ((ax_p, engine.history_P, "Pressure (psi)"),
+                                       (ax_t, engine.history_T, "Temperature (\N{DEGREE SIGN}F)")):
+            ax.clear()
+            ax.set_facecolor("#101a2e")
+            ax.grid(True, alpha=0.3)
+            ax.set_ylabel(label, color="#e0f2fe")
+            ax.tick_params(colors="#e0f2fe")
+            for i, s in enumerate(engine.sensors):
+                ax.plot(t_hist, [row[i] for row in series_hist], lw=1.5,
+                        label=f"{s.name} ({s.depth_ft:.0f} ft)")
+            ax.legend(fontsize=7, loc="upper right")
+        ax_t.set_xlabel("Time (s)", color="#e0f2fe")
+        avg_drift = float(np.mean(engine.current_drifts))
+        fig.suptitle(
+            f"GEA Deep-Well Simulator  |  t={engine.time:.1f}s  |  "
+            f"Avg Drift={avg_drift:.3f}% FS/yr  |  TD={cfg.td_ft:.0f} ft  |  "
+            f"canonical K_MEX=25/12, \N{GREEK CAPITAL LETTER PHI}_res=0.84 (locked)",
+            fontsize=12, color="#67e8f9")
+        return []
+
+    ani = FuncAnimation(fig, update, interval=120, blit=False, cache_frame_data=False)
+    plt.tight_layout()
+    plt.show()
+    out = engine.export_csv()
+    print(f"Exported: {out.resolve()}")
+    return ani
+
+
+if __name__ == "__main__":
+    run_demo()

gea/modbus.py

@@ -0,0 +1,229 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+"""modbus — the real Modbus client, connectivity tier 4 (v1.11.0).
+
+Daniel GO 2026-08-24: implement the live-protocol tap for the G6-class target
+(Modbus RS485/TCP surface interface, declared by the tool library from the
+GEOQ 177 spec-table footnotes) as REAL protocol code behind a guarded
+optional dependency — the same pattern as the PyQt6 front-end:
+
+    pip install pymodbus        (the package works fully without it;
+                                 this tier simply refuses until installed)
+
+Honesty rules, unchanged:
+  * READ-ONLY. The tap issues ONLY read_holding_registers /
+    read_input_registers. There is no code path that writes to a device.
+  * REGISTER MAPS ARE USER-SUPPLIED AND CITATION-MANDATORY. No public G6
+    register map was published on the fetched pages, so the library ships
+    NO device map — a map without a `source` citation is rejected (Rule 7),
+    exactly like the gauge specs. The shipped example map is labeled
+    EXAMPLE_TEST_FIXTURE and describes the in-process loopback server used
+    for verification, NOT a device.
+  * Decoding is done with `struct` on the raw 16-bit registers (word order
+    from the map) — no dependence on pymodbus payload helpers, so the tap
+    is stable across pymodbus versions.
+
+Output is the same normalized `LiveStream` every other port produces; the
+reconciler does not know or care that the samples came over a wire.
+
+Headless-safe: numpy + stdlib; pymodbus only inside guarded paths.
+"""
+
+from __future__ import annotations
+
+import json
+import struct
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import numpy as np
+
+from .ports import (LiveStream, StreamChannel, PortSpec, PORT_REGISTRY)
+
+PYMODBUS_AVAILABLE = False
+try:
+    from pymodbus.client import ModbusTcpClient          # noqa: F401
+    PYMODBUS_AVAILABLE = True
+except ImportError:
+    ModbusTcpClient = None
+
+_TYPES = {'float32': 2, 'uint16': 1, 'int16': 1, 'uint32': 2, 'int32': 2}
+
+
+@dataclass(frozen=True)
+class RegisterEntry:
+    channel: str
+    address: int
+    type: str = 'float32'
+    unit: str = ''
+    scale: float = 1.0
+
+    def word_count(self) -> int:
+        return _TYPES[self.type]
+
+
+@dataclass(frozen=True)
+class RegisterMap:
+    """The site's register layout. `source` citation is MANDATORY (Rule 7):
+    a register map must name the document it came from — a G6/site manual,
+    or the loopback test fixture, never an invention."""
+    name: str
+    source: str
+    registers: List[RegisterEntry]
+    unit_id: int = 1
+    word_order: str = 'big'          # register word order for 32-bit types
+    table: str = 'holding'           # 'holding' | 'input'
+
+    def __post_init__(self):
+        if not self.source or len(self.source) < 20:
+            raise ValueError("register map requires a substantive 'source' citation "
+                             "(Rule 7: the library does not invent device layouts)")
+        for r in self.registers:
+            if r.type not in _TYPES:
+                raise ValueError(f"unsupported register type '{r.type}'")
+        if self.table not in ('holding', 'input'):
+            raise ValueError("table must be 'holding' or 'input'")
+
+
+def load_register_map(path_or_dict) -> RegisterMap:
+    d = path_or_dict
+    if not isinstance(d, dict):
+        with Path(path_or_dict).open(encoding='utf-8') as f:
+            d = json.load(f)
+    regs = [RegisterEntry(channel=r['channel'], address=int(r['address']),
+                          type=r.get('type', 'float32'), unit=r.get('unit', ''),
+                          scale=float(r.get('scale', 1.0)))
+            for r in d['registers']]
+    return RegisterMap(name=d.get('name', 'register_map'), source=d.get('source', ''),
+                       registers=regs, unit_id=int(d.get('unit_id', 1)),
+                       word_order=d.get('word_order', 'big'),
+                       table=d.get('table', 'holding'))
+
+
+def _decode(words: List[int], rtype: str, word_order: str) -> float:
+    if rtype == 'uint16':
+        return float(words[0])
+    if rtype == 'int16':
+        return float(struct.unpack('>h', struct.pack('>H', words[0]))[0])
+    w = words if word_order == 'big' else list(reversed(words))
+    raw = struct.pack('>HH', w[0], w[1])
+    if rtype == 'float32':
+        return float(struct.unpack('>f', raw)[0])
+    if rtype == 'uint32':
+        return float(struct.unpack('>I', raw)[0])
+    if rtype == 'int32':
+        return float(struct.unpack('>i', raw)[0])
+    raise ValueError(rtype)
+
+
+class ModbusHistorianTap:
+    """READ-ONLY Modbus tap: polls the mapped registers, accumulates samples,
+    emits the normalized LiveStream. Caller schedules the polling cadence."""
+
+    def __init__(self, host: str, port: int = 502,
+                 register_map: RegisterMap | dict | str = None,
+                 timeout_s: float = 3.0):
+        if not PYMODBUS_AVAILABLE:
+            raise NotImplementedError(
+                "Modbus tier requires the optional dependency: pip install pymodbus "
+                "(guarded import - the rest of the package runs without it)")
+        if register_map is None:
+            raise ValueError("a register map is required (user-supplied, cited - Rule 7)")
+        self.map = register_map if isinstance(register_map, RegisterMap) else load_register_map(register_map)
+        self.host, self.port = host, int(port)
+        self.client = ModbusTcpClient(host, port=int(port), timeout=timeout_s)
+        self._t0: Optional[float] = None
+        self.times: List[float] = []
+        self.samples: Dict[str, List[float]] = {r.channel: [] for r in self.map.registers}
+
+    def connect(self) -> bool:
+        return bool(self.client.connect())
+
+    def close(self) -> None:
+        self.client.close()
+
+    def poll_once(self) -> Dict[str, float]:
+        """One READ-ONLY poll of every mapped register."""
+        now = time.monotonic()
+        if self._t0 is None:
+            self._t0 = now
+        out: Dict[str, float] = {}
+        for r in self.map.registers:
+            if self.map.table == 'holding':
+                rr = self.client.read_holding_registers(r.address, count=r.word_count(),
+                                                        device_id=self.map.unit_id)
+            else:
+                rr = self.client.read_input_registers(r.address, count=r.word_count(),
+                                                      device_id=self.map.unit_id)
+            if rr.isError():
+                out[r.channel] = float('nan')
+            else:
+                out[r.channel] = _decode(list(rr.registers), r.type, self.map.word_order) * r.scale
+        self.times.append(now - self._t0)
+        for ch, v in out.items():
+            self.samples[ch].append(v)
+        return out
+
+    def collect(self, n_polls: int, interval_s: float = 0.0) -> LiveStream:
+        for k in range(int(n_polls)):
+            self.poll_once()
+            if interval_s > 0 and k < n_polls - 1:
+                time.sleep(interval_s)
+        return self.to_live_stream()
+
+    def to_live_stream(self) -> LiveStream:
+        chans = {r.channel: StreamChannel(name=r.channel, unit=r.unit,
+                                          values=np.array(self.samples[r.channel], dtype=float))
+                 for r in self.map.registers}
+        return LiveStream(name=f"modbus_{self.host}", source_format='modbus_g6',
+                          index_kind='time_s', index=np.array(self.times, dtype=float),
+                          channels=chans,
+                          meta={'host': self.host, 'port': str(self.port),
+                                'map': self.map.name, 'map_source': self.map.source[:100]})
+
+
+def read_modbus(config) -> LiveStream:
+    """The registry reader: config is a JSON path or dict with host, port,
+    register_map (path/dict), polls, interval_s. Read-only end to end."""
+    d = config
+    if not isinstance(d, dict):
+        with Path(config).open(encoding='utf-8') as f:
+            d = json.load(f)
+    missing = [k for k in ('host', 'register_map') if not d.get(k)]
+    if missing:
+        raise NotImplementedError(
+            "port 'modbus_g6' is IMPLEMENTED but this call lacks site details - "
+            f"config missing: {', '.join(missing)}. The protocol code is real "
+            "(loopback-verified); the library refuses ONLY because the site's "
+            "host/register map is not supplied, and register maps are "
+            "citation-mandatory (Rule 7: no invented device layouts).")
+    tap = ModbusHistorianTap(host=d['host'], port=int(d.get('port', 502)),
+                             register_map=d['register_map'],
+                             timeout_s=float(d.get('timeout_s', 3.0)))
+    if not tap.connect():
+        raise ConnectionError(f"could not connect to {d['host']}:{d.get('port', 502)} (read-only tap)")
+    try:
+        return tap.collect(int(d.get('polls', 10)), float(d.get('interval_s', 0.0)))
+    finally:
+        tap.close()
+
+
+def _refuse_no_dep(*a, **k):
+    raise NotImplementedError(
+        "port 'modbus_g6' requires the optional dependency: pip install pymodbus "
+        "(protocol code is implemented; only the dependency is missing)")
+
+
+# Upgrade the registry entry declared in ports (imported by __init__ after ports):
+PORT_REGISTRY['modbus_g6'] = PortSpec(
+    name='modbus_g6',
+    transport='Modbus TCP / RS485-gateway (G6 interface card class)',
+    status=('IMPLEMENTED_REQUIRES_SITE_CONFIG' if PYMODBUS_AVAILABLE
+            else 'DECLARED_DEPENDENCY_MISSING'),
+    reader=(read_modbus if PYMODBUS_AVAILABLE else _refuse_no_dep),
+    detail=("READ-ONLY tap; real protocol code (v1.11.0); register map is user-supplied "
+            "and citation-mandatory - no public G6 map exists in the fetched sources, so "
+            "none is shipped; loopback-verified against an in-process pymodbus server"))