acumatica-cli 0.31.0__tar.gz → 0.32.0__tar.gz

{acumatica_cli-0.31.0 → acumatica_cli-0.32.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acumatica-cli
-Version: 0.31.0
+Version: 0.32.0
 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.31.0 → acumatica_cli-0.32.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acumatica-cli"
-version = "0.31.0"
+version = "0.32.0"
 description = "Acumatica ERP Config-as-Code: tenant provisioning, baseline config, and reference data"
 license = "PolyForm-Noncommercial-1.0.0"
 readme = "README.md"

{acumatica_cli-0.31.0 → acumatica_cli-0.32.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "acumatica-cli"
-version = "0.31.0"
+version = "0.32.0"
 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.31.0 → acumatica_cli-0.32.0}/src/acumatica_cli/client.py

@@ -12,6 +12,11 @@ import httpx
 
 from .config import Instance
 
+# Contract control fields travel bare on wrap and stay on unwrap of
+# value-field rows (V54). Files-style rows that unwrap to only these
+# keys are elided so expanded `files` descriptors stay noise.
+_BARE_FIELDS = frozenset({"id", "delete"})
+
 
 def wrap(record: dict[str, Any]) -> dict[str, Any]:
     """Plain dict -> contract-API body: {"Field": {"value": ...}}.
@@ -33,31 +38,35 @@ def wrap(record: dict[str, Any]) -> dict[str, Any]:
             return wrap(v)
         return {"value": v}
 
-    return {k: v if k in ("id", "delete") else _value(v) for k, v in record.items()}
+    return {k: v if k in _BARE_FIELDS else _value(v) for k, v in record.items()}
 
 
 def unwrap(entity: dict[str, Any]) -> dict[str, Any]:
     """Contract-API entity -> plain dict (value fields + detail arrays).
 
-    Inverse of wrap (T60/T65): a list of dicts unwraps row by row; lists
-    that are empty or whose rows carry no value fields are elided (a
-    detail array the source never claimed must not surface, and expanded
-    `files` descriptors are plain dicts that would unwrap to noise). A
-    non-value dict is a linked entity — unwrapped recursively, kept only
-    when something survives, so bookkeeping dicts (custom, _links, note)
-    stay excluded exactly as before.
+    Inverse of wrap (T60/T65/V54): a list of dicts unwraps row by row;
+    lists that are empty or whose rows carry no value fields are elided
+    (a detail array the source never claimed must not surface, and
+    expanded `files` descriptors are plain dicts that would unwrap to
+    noise). A non-value dict is a linked entity — unwrapped recursively,
+    kept only when something survives, so bookkeeping dicts (custom,
+    _links, note) stay excluded exactly as before. `id` and `delete`
+    stay on records and on detail rows that also have value fields so a
+    later PUT updates the existing line (V54).
     """
     out: dict[str, Any] = {}
     for k, v in entity.items():
-        if isinstance(v, dict) and "value" in v:
+        if k in _BARE_FIELDS and not isinstance(v, (dict, list)):
+            out[k] = v
+        elif isinstance(v, dict) and "value" in v:
             out[k] = v["value"]
         elif isinstance(v, dict):
             nested = unwrap(v)
             if nested:
                 out[k] = nested
         elif isinstance(v, list) and v and all(isinstance(row, dict) for row in v):
-            rows = [unwrap(row) for row in v]
-            if any(rows):
+            rows = [row for row in (unwrap(r) for r in v) if set(row) - _BARE_FIELDS]
+            if rows:
                 out[k] = rows
     return out
 
@@ -326,7 +335,7 @@ class AcumaticaClient:
 
     @staticmethod
     def _checked(r: httpx.Response) -> httpx.Response:
-        """Surface exceptionMessage + nested Field.error (V46), not status alone."""
+        """Surface exceptionMessage + innerException + Field.error (V46)."""
         if r.is_error:
             detail = ""
             try:
@@ -338,12 +347,13 @@ class AcumaticaClient:
                         or body.get("error")
                         or ""
                     )
-                    # nested contract-API validation often rides here
-                    if not detail and isinstance(body.get("innerException"), dict):
+                    if isinstance(body.get("innerException"), dict):
                         inner = body["innerException"]
-                        detail = (
+                        inner_msg = (
                             inner.get("exceptionMessage") or inner.get("message") or ""
                         )
+                        if inner_msg:
+                            detail = f"{detail}; {inner_msg}" if detail else inner_msg
                     field_errs = AcumaticaClient._field_errors(body)
                     if field_errs:
                         joined = "; ".join(field_errs)

{acumatica_cli-0.31.0 → acumatica_cli-0.32.0}/src/acumatica_cli/extract.py

@@ -46,6 +46,8 @@ from .models import Model, validation_summary
 from .seed import (
     NUMBERING_RUNTIME_FIELDS,
     PASSWORD_FIELDS,
+    _calendar_day,  # pyright: ignore[reportPrivateUsage]
+    _drop_path_ignored,  # pyright: ignore[reportPrivateUsage]
     active_bootstrap,
     resolve_endpoint,
 )
@@ -263,14 +265,16 @@ def _fetch(client: AcumaticaClient, spec: EntitySpec) -> list[dict[str, Any]]:
 
 # Server-assigned / audit fields that must never enter seed (B11 class).
 # Applied recursively under linked entities and detail rows after expand
-# (T65/T119): MainContact.ContactID and AllowedCashAccounts.LastModified*
-# would otherwise permanent-red-diff after re-apply on a fresh tenant.
+# (T65/T119). `id`/`delete` stay in unwrap for run-capture PUT (V54);
+# extract still strips them so seed is tenant-portable.
 _SERVER_DERIVED = frozenset(
     {
         "ContactID",
         "CreatedDateTime",
         "LastModifiedDateTime",
         "NoteID",
+        "delete",
+        "id",
         "tstamp",
     }
 )
@@ -293,6 +297,26 @@ def _elide_server_derived(value: Any) -> Any:
     return value
 
 
+def _date_strip(value: Any) -> Any:
+    """DateTimeValue seed emit: keep YYYY-MM-DD prefix only (V55)."""
+    if isinstance(value, dict):
+        return {k: _date_strip(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_date_strip(v) for v in value]
+    if isinstance(value, str):
+        day = _calendar_day(value)
+        if day is not None:
+            return day
+    return value
+
+
+def _strip_write_only_get_omit(entity: str, field: str, value: Any) -> Any:
+    """Drop path-qualified write-only GET-omit fields from detail rows (V56)."""
+    if not isinstance(value, list):
+        return value
+    return _drop_path_ignored(entity, field, value)
+
+
 def _kept_fields(spec: EntitySpec, record: dict[str, Any]) -> dict[str, Any]:
     """Apply include/strip + nested server-derived elision to one unwrapped row."""
     keep: dict[str, Any] = {}
@@ -313,6 +337,7 @@ def _kept_fields(spec: EntitySpec, record: dict[str, Any]) -> dict[str, Any]:
             continue
         # Nested ContactID / LastModifiedDateTime under expand (T65/T119).
         cleaned = _elide_server_derived(value)
+        cleaned = _strip_write_only_get_omit(spec.entity, field, cleaned)
         if cleaned is None or cleaned == "":
             continue
         if isinstance(cleaned, (dict, list)) and not cleaned:
@@ -320,7 +345,7 @@ def _kept_fields(spec: EntitySpec, record: dict[str, Any]) -> dict[str, Any]:
         keep[field] = cleaned
     ordered = {k: keep[k] for k in spec.keys if k in keep}
     ordered |= {k: keep[k] for k in sorted(keep.keys() - set(spec.keys))}
-    return ordered
+    return _date_strip(ordered)
 
 
 def _shape(spec: EntitySpec, live: list[dict[str, Any]]) -> list[dict[str, Any]]:

{acumatica_cli-0.31.0 → acumatica_cli-0.32.0}/src/acumatica_cli/seed.py

@@ -52,6 +52,7 @@ Default Currency = CM201000 list), so an ambiguous file is a hard error,
 never a silent Default-endpoint PUT.
 """
 
+import re
 from pathlib import Path
 from typing import Any
 
@@ -88,7 +89,34 @@ PASSWORD_FIELDS = frozenset({"Password", "b64__Password"})
 # PUTs them (re-apply must not reset live counters).
 NUMBERING_RUNTIME_FIELDS = frozenset({"LastNbr"})
 # Fields omitted from source↔live compare (V39 write-only + V40 runtime).
+# Field-name deny at every nesting level. Do not add bare ``Value`` here —
+# that would hide real drift on unrelated fields (V56).
 _DIFF_IGNORE_FIELDS = PASSWORD_FIELDS | NUMBERING_RUNTIME_FIELDS
+# Path-qualified write-only GET-omit (V56): (entity, detail, field).
+# Diff ignores; extract strips; apply still PUTs when present in YAML.
+_DIFF_IGNORE_PATHS = frozenset({("LotSerialClass", "Segments", "Value")})
+
+
+def _diff_ignored(entity: str, *path: str) -> bool:
+    """True when source↔live compare skips this field (V39/V40/V56)."""
+    if path and path[-1] in _DIFF_IGNORE_FIELDS:
+        return True
+    return (entity, *path) in _DIFF_IGNORE_PATHS
+
+
+def _drop_path_ignored(entity: str, field: str, rows: list[Any]) -> list[Any]:
+    """Strip path-qualified GET-omit fields from detail rows (V56)."""
+    drop = {
+        sub for (ent, det, sub) in _DIFF_IGNORE_PATHS if ent == entity and det == field
+    }
+    if not drop:
+        return rows
+    return [
+        {k: v for k, v in row.items() if k not in drop}
+        if isinstance(row, dict)
+        else row
+        for row in rows
+    ]
 
 
 def active_bootstrap(root: Path | None = None) -> tuple[str, frozenset[str]]:
@@ -251,18 +279,33 @@ def load_baseline(path: Path) -> BaselineFile | ActionFile:
     return parsed
 
 
+# ISO date or DateTimeValue: calendar-day prefix only (V55). Random strings
+# that merely contain T stay untouched.
+_ISO_CALENDAR_DAY = re.compile(r"(\d{4}-\d{2}-\d{2})(T.*)?")
+
+
+def _calendar_day(text: str) -> str | None:
+    """YYYY-MM-DD when ``text`` is ISO date/datetime; else None. No TZ convert."""
+    m = _ISO_CALENDAR_DAY.fullmatch(text)
+    return None if m is None else m.group(1)
+
+
 def _norm(value: Any) -> str:
-    """Comparable form: bools case-folded, numbers by value, rest stringified.
+    """Comparable form: bools case-folded, numbers by value, dates by day.
 
     Numbers compare by value, not spelling - a YAML `0` against the
     endpoint's `0.0` (DecimalValue fields come back as floats) is not
-    drift (T13).
+    drift (T13). Date-only ``YYYY-MM-DD`` matches a live DateTimeValue on
+    the same calendar day (strip ``T...offset``); a different day still
+    drifts (V55). No timezone conversion.
     """
     if isinstance(value, bool):
         return str(value).lower()
     if isinstance(value, int | float):
         return repr(float(value))
-    return str(value).strip()
+    text = str(value).strip()
+    day = _calendar_day(text)
+    return text if day is None else day
 
 
 def _filter_for(record: dict[str, Any], keys: list[str]) -> str:
@@ -636,13 +679,18 @@ def diff(client: AcumaticaClient, baseline: BaselineFile | ActionFile) -> list[s
             drifts.append(f"{label}: missing on tenant")
             continue
         actual = unwrap(live)
-        # V39/V40: never compare write-only password or runtime numbering counters
-        fields = {k: v for k, v in record.items() if k not in _DIFF_IGNORE_FIELDS}
+        # V39/V40/V56: never compare write-only, runtime, or GET-omit paths
+        fields = {
+            k: v for k, v in record.items() if not _diff_ignored(baseline.entity, k)
+        }
         for field, expected in fields.items():
             if isinstance(expected, list):
                 key = (baseline.detail_keys or {})[field]  # load-validated
-                live_rows = actual.get(field, [])
-                drifts.extend(_diff_details(label, field, key, expected, live_rows))
+                want_rows = _drop_path_ignored(baseline.entity, field, expected)
+                live_rows = _drop_path_ignored(
+                    baseline.entity, field, actual.get(field, [])
+                )
+                drifts.extend(_diff_details(label, field, key, want_rows, live_rows))
             elif isinstance(expected, dict):
                 drifts.extend(
                     _diff_nested(f"{label}.{field}", expected, actual.get(field))