acumatica-cli 0.12.0__tar.gz → 0.12.1__tar.gz

{acumatica_cli-0.12.0 → acumatica_cli-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acumatica-cli
-Version: 0.12.0
+Version: 0.12.1
 Summary: Acumatica ERP Config-as-Code: tenant provisioning, baseline config, and reference data
 Author: Konstantin Borovik
 Author-email: Konstantin Borovik <kb@lab5.ca>

{acumatica_cli-0.12.0 → acumatica_cli-0.12.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acumatica-cli"
-version = "0.12.0"
+version = "0.12.1"
 description = "Acumatica ERP Config-as-Code: tenant provisioning, baseline config, and reference data"
 authors = [{ name = "Konstantin Borovik", email = "kb@lab5.ca" }]
 license = "PolyForm-Noncommercial-1.0.0"

{acumatica_cli-0.12.0 → acumatica_cli-0.12.1}/src/acumatica_cli/cli.py

@@ -537,37 +537,73 @@ def config_check(ctx: click.Context, strict: bool) -> None:
     # both live probes run through the exact objects live commands use, so
     # a pass here proves the real code path, not a parallel one
     inst = _resolve_instance(ctx)
-    failed = _probe_target(root, inst, strict=strict)
+    failed, claimed_erp = _probe_target(root, inst, strict=strict)
+    if not _probe_rest(inst, claimed_erp):
+        failed = True
+    if not _probe_ssh(inst):
+        failed = True
+    if failed:
+        raise SystemExit(1)
+
+
+def _probe_rest(inst: Instance, claimed_erp: str | None) -> bool:
+    """REST login + endpoints + optional ERP build; True = all passed.
+
+    Entering the client is the probe: login + landed-tenant verify (V5);
+    context manager guarantees logout (V6). One GET /entity feeds endpoints
+    (T74/T90) and optional ERP build (T92).
+    """
     try:
-        # entering the client is the whole probe: login + landed-tenant
-        # verify (V5), and the context manager guarantees logout (V6);
-        # endpoints probe (T74) reuses the same session when login succeeds
         with AcumaticaClient(inst) as client:
             output.data(f"ok rest ({inst.base_url}, tenant {inst.tenant})")
-            if not _probe_endpoints(client, inst):
-                failed = True
+            return _probe_entity_root(client, inst, claimed_erp)
     except (RuntimeError, httpx.HTTPError) as exc:
         output.data(f"fail rest: {exc}")
-        failed = True
+        return False
+
+
+def _probe_entity_root(
+    client: AcumaticaClient, inst: Instance, claimed_erp: str | None
+) -> bool:
+    """Endpoints (+ ERP when claimed); True = all passed."""
+    ok = True
+    try:
+        endpoints, live_build = client.entity_root()
+    except (RuntimeError, httpx.HTTPError) as exc:
+        output.data(f"fail endpoints: {exc}")
+        endpoints, live_build = [], None
+        ok = False
+    else:
+        if not _probe_endpoints(endpoints, inst):
+            ok = False
+    if claimed_erp is not None and not _probe_erp(claimed_erp, live_build):
+        ok = False
+    return ok
+
+
+def _probe_ssh(inst: Instance) -> bool:
+    """SSH ping or skip when unset; True = pass/skip, False = fail."""
     if not inst.ssh:
         # V3/I.cmd: ACU_SSH optional — hosted data-plane path skips, never fails
         output.data("skip ssh (ACU_SSH not set)")
-    else:
-        try:
-            TenantManager(inst).ping()
-            output.data(f"ok ssh ({inst.ssh})")
-        except RuntimeError as exc:
-            output.data(f"fail ssh: {exc}")
-            failed = True
-    if failed:
-        raise SystemExit(1)
+        return True
+    try:
+        TenantManager(inst).ping()
+        output.data(f"ok ssh ({inst.ssh})")
+        return True
+    except RuntimeError as exc:
+        output.data(f"fail ssh: {exc}")
+        return False
 
 
-def _probe_target(root: Path | None, inst: Instance, *, strict: bool) -> bool:
-    """Emit the local target probe line; return True when it failed (V27).
+def _probe_target(
+    root: Path | None, inst: Instance, *, strict: bool
+) -> tuple[bool, str | None]:
+    """Emit local target probe; return ``(failed, claimed_erp?)`` (V27).
 
     Invalid target hard-exits (any loader). Missing under data root warns
-    unless --strict. No data root → skip. Match → ok (erp claimed-only).
+    unless --strict. No data root → skip. Match → ok + claimed ``erp`` for
+    the live ERP probe after REST (T92).
     """
     try:
         target = load_target(root)
@@ -576,7 +612,7 @@ def _probe_target(root: Path | None, inst: Instance, *, strict: bool) -> bool:
         raise SystemExit(1) from exc
     if root is None:
         output.data("skip target (no data root)")
-        return False
+        return False, None
     if target is None:
         msg = (
             f"target: no target.yaml under {root} - dataset verified matrix "
@@ -584,35 +620,27 @@ def _probe_target(root: Path | None, inst: Instance, *, strict: bool) -> bool:
             "to require it"
         )
         output.data(f"{'fail' if strict else 'warn'} {msg}")
-        return strict
+        return strict, None
     if target.default_api != inst.api_version:
         output.data(
             f"fail target: dataset default_api={target.default_api} vs "
             f"configured {inst.api_version}"
         )
-        return True
+        return True, None
     output.data(
         f"ok target (default_api={target.default_api} matches configured; "
         f"erp={target.erp} claimed)"
     )
-    # T76: no stable HTTP ERP-build discovery (V12) — keep erp claimed-only;
-    # skip rather than invent SSH/sqlcmd (control-plane exclusion, V1)
-    output.data(f"skip erp (live probe not available; claimed {target.erp})")
-    return False
+    return False, target.erp
 
 
-def _probe_endpoints(client: AcumaticaClient, inst: Instance) -> bool:
+def _probe_endpoints(endpoints: list[tuple[str, str]], inst: Instance) -> bool:
     """Emit endpoints probe; return True on pass, False on fail (V12/V27).
 
     Exact match: a Default entry whose version half equals
-    ``Instance.api_version``. Fail-closed when GET /entity is unparseable.
+    ``Instance.api_version``. Caller already fail-closed on unparseable GET.
     """
     want = f"Default/{inst.api_version}"
-    try:
-        endpoints = client.list_endpoints()
-    except (RuntimeError, httpx.HTTPError) as exc:
-        output.data(f"fail endpoints: {exc}")
-        return False
     defaults = [v for name, v in endpoints if name == "Default"]
     if inst.api_version in defaults:
         output.data(f"ok endpoints ({want} present)")
@@ -625,6 +653,34 @@ def _probe_endpoints(client: AcumaticaClient, inst: Instance) -> bool:
     return False
 
 
+def _major_minor(version: str) -> str:
+    """First two dotted segments (T76/T92 major.minor match)."""
+    parts = version.split(".")
+    if len(parts) >= 2:
+        return f"{parts[0]}.{parts[1]}"
+    return version
+
+
+def _probe_erp(claimed: str, live: str | None) -> bool:
+    """Emit ERP probe; return True on pass/skip, False on fail (T92).
+
+    Live id comes from 26.x ``GET /entity`` wrapper
+    ``version.acumaticaBuildVersion``. Bare array → skip (no HTTP surface).
+    Compare major.minor only — patch builds may drift within a claimed line.
+    """
+    if live is None:
+        output.data(f"skip erp (live probe not available; claimed {claimed})")
+        return True
+    if _major_minor(live) == _major_minor(claimed):
+        output.data(f"ok erp ({live} matches claimed {claimed})")
+        return True
+    output.data(
+        f"fail erp: live {live} vs claimed {claimed} "
+        f"(major.minor {_major_minor(live)} vs {_major_minor(claimed)})"
+    )
+    return False
+
+
 SEED_DIRS = ("bootstrap", "baseline", "setup", "master")
 
 

{acumatica_cli-0.12.0 → acumatica_cli-0.12.1}/src/acumatica_cli/client.py

@@ -65,10 +65,22 @@ def unwrap(entity: dict[str, Any]) -> dict[str, Any]:
 def parse_entity_list(response: httpx.Response) -> list[tuple[str, str]]:
     """Parse ``GET /entity`` into ``[(name, version), ...]`` (fail-closed).
 
-    Vendor contract shape (Acumatica help + docs/rest-api.md): a JSON array
-    of objects with ``name`` and ``version`` strings. Unparseable body →
-    RuntimeError with status, content-type, and a short raw hint so a
-    shape change is re-verified (V12) rather than silently skipped.
+    Dual shape (V31 / gh #20): top-level JSON array (legacy) or object with
+    an ``endpoints`` array (26.x wrapper). Each row needs string ``name``
+    and ``version``. Unparseable body → RuntimeError with status,
+    content-type, and a short raw hint so a shape change is re-verified
+    (V12) rather than silently skipped.
+    """
+    return parse_entity_response(response)[0]
+
+
+def parse_entity_response(
+    response: httpx.Response,
+) -> tuple[list[tuple[str, str]], str | None]:
+    """Parse ``GET /entity`` → ``(endpoints, acumatica_build_version?)``.
+
+    Endpoints dual-shape per V31. Build id is ``version.acumaticaBuildVersion``
+    on the 26.x wrapper only; bare array → ``None`` (T92).
     """
     try:
         body = response.json()
@@ -80,15 +92,17 @@ def parse_entity_list(response: httpx.Response) -> list[tuple[str, str]]:
             f"content-type {response.headers.get('content-type', '?')}; "
             f"first 200 chars: {hint})"
         ) from exc
-    if not isinstance(body, list) or not body:
+    rows = _entity_list_rows(body)
+    if rows is None:
         hint = str(body)[:200]
         raise RuntimeError(
             "GET /entity response not parseable as endpoint list "
-            f"(status {response.status_code}; expected non-empty JSON array; "
+            f"(status {response.status_code}; expected non-empty JSON array "
+            "or object with non-empty 'endpoints' array; "
             f"first 200 chars: {hint})"
         )
     out: list[tuple[str, str]] = []
-    for item in body:
+    for item in rows:
         if not isinstance(item, dict):
             raise RuntimeError(
                 "GET /entity response not parseable as endpoint list "
@@ -102,7 +116,31 @@ def parse_entity_list(response: httpx.Response) -> list[tuple[str, str]]:
                 f"(row missing string name/version: {item!r})"
             )
         out.append((name, version))
-    return out
+    return out, _entity_build_version(body)
+
+
+def _entity_list_rows(body: Any) -> list[Any] | None:
+    """Return endpoint row list from array or 26.x wrapper; else None."""
+    if isinstance(body, list) and body:
+        return body
+    if isinstance(body, dict):
+        endpoints = body.get("endpoints")
+        if isinstance(endpoints, list) and endpoints:
+            return endpoints
+    return None
+
+
+def _entity_build_version(body: Any) -> str | None:
+    """``version.acumaticaBuildVersion`` from 26.x wrapper; else None."""
+    if not isinstance(body, dict):
+        return None
+    version = body.get("version")
+    if not isinstance(version, dict):
+        return None
+    build = version.get("acumaticaBuildVersion")
+    if isinstance(build, str) and build:
+        return build
+    return None
 
 
 # The list GET's optimized-export failure (B9): the contract API's list GET
@@ -245,8 +283,16 @@ class AcumaticaClient:
 
         Fail-closed on unparseable body — see ``parse_entity_list``.
         """
+        return self.entity_root()[0]
+
+    def entity_root(self) -> tuple[list[tuple[str, str]], str | None]:
+        """Authenticated ``GET /entity`` → endpoints + optional ERP build id.
+
+        Build id is present only on the 26.x wrapper
+        (``version.acumaticaBuildVersion``). Bare array → ``None`` (T92).
+        """
         r = self._checked(self._http.get("/entity"))
-        return parse_entity_list(r)
+        return parse_entity_response(r)
 
     @staticmethod
     def _checked(r: httpx.Response) -> httpx.Response: