acumatica-cli 0.17.0__tar.gz → 0.18.0__tar.gz

{acumatica_cli-0.17.0 → acumatica_cli-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acumatica-cli
-Version: 0.17.0
+Version: 0.18.0
 Summary: Acumatica ERP Config-as-Code: tenant provisioning, baseline config, and reference data
 Author: Konstantin Borovik
 Author-email: Konstantin Borovik <kb@lab5.ca>
@@ -107,7 +107,7 @@ A path like `config/` expands nested seed dirs in that fixed order.
 `extract` always writes under `config/{bootstrap,baseline,setup,master}/` (catalog-driven; never root SEED_DIRS).
 `inventory` is offline (no REST/SSH/password): SM203520 Settings XML ZIP or `ac.exe export xml` folder writes to `inventory/`.
 `reconcile` is offline: compare `inventory/` to optional `config/` and write `findings/` only (never writes seed).
-Optional `snapshot_map.yaml` (data-repo root or package defaults) maps DAC tables to catalog entities and normalizes join (pad-trim, key/field aliases, Account/Sub FK CD resolve).
+Optional `snapshot_map.yaml` (data-repo root or package defaults) maps DAC tables to catalog entities and normalizes join (pad-trim, key/field aliases, Account/Sub FK CD resolve, enum label→code).
 See [docs/demo-seed.md](docs/demo-seed.md).
 `acu --completion` emits a completion script for bash, zsh, or fish — source it from your shell profile.
 Run `acu <command> --help` for details on any command.

{acumatica_cli-0.17.0 → acumatica_cli-0.18.0}/README.md

@@ -89,7 +89,7 @@ A path like `config/` expands nested seed dirs in that fixed order.
 `extract` always writes under `config/{bootstrap,baseline,setup,master}/` (catalog-driven; never root SEED_DIRS).
 `inventory` is offline (no REST/SSH/password): SM203520 Settings XML ZIP or `ac.exe export xml` folder writes to `inventory/`.
 `reconcile` is offline: compare `inventory/` to optional `config/` and write `findings/` only (never writes seed).
-Optional `snapshot_map.yaml` (data-repo root or package defaults) maps DAC tables to catalog entities and normalizes join (pad-trim, key/field aliases, Account/Sub FK CD resolve).
+Optional `snapshot_map.yaml` (data-repo root or package defaults) maps DAC tables to catalog entities and normalizes join (pad-trim, key/field aliases, Account/Sub FK CD resolve, enum label→code).
 See [docs/demo-seed.md](docs/demo-seed.md).
 `acu --completion` emits a completion script for bash, zsh, or fish — source it from your shell profile.
 Run `acu <command> --help` for details on any command.

{acumatica_cli-0.17.0 → acumatica_cli-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "acumatica-cli"
-version = "0.17.0"
+version = "0.18.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.17.0 → acumatica_cli-0.18.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "acumatica-cli"
-version = "0.17.0"
+version = "0.18.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.17.0 → acumatica_cli-0.18.0}/src/acumatica_cli/cli.py

@@ -1104,9 +1104,11 @@ def reconcile_cmd(
     Exit 0 clean, 1 IO/parse fail; never 2 (conflicts are findings, not
     drift). Optional snapshot_map.yaml maps DAC tables to catalog
     entities (absent → identity match on entity name) and may declare
-    keys:/fields: seed→inv aliases plus resolvers:/resolves: for FK
-    int→CD compare (package defaults cover Sub, UnitOfMeasure,
-    ReasonCode/VendorClass Account+Sub). Compare always pad-trims strings.
+    keys:/fields: seed→inv aliases, resolvers:/resolves: for FK int→CD,
+    and enums: label→code (package defaults cover Sub/UOM aliases,
+    ReasonCode/VendorClass/PostingClass/CashAccount Account+Sub,
+    ReasonCode.Usage + Account Type/Active bools, etc.). Compare always
+    pad-trims strings.
     """
     inv = (
         inventory_dir

{acumatica_cli-0.17.0 → acumatica_cli-0.18.0}/src/acumatica_cli/reconcile.py

@@ -24,7 +24,9 @@ Per-row optional ``keys:`` / ``fields:`` maps rename seed names →
 inventory column names (V38 M3) so e.g. SubaccountCD joins SubCD and
 UnitID joins Unit without false key-skips. Global ``resolvers:`` plus
 per-row ``resolves:`` map inv int FKs → CD strings before compare (V38 M4)
-so seed CD space matches inventory IDs (Account/Sub first).
+so seed CD space matches inventory IDs (Account/Sub first). Global
+``enums:`` plus per-row ``enums:`` map REST labels → DAC codes (V38 M5)
+so e.g. Usage Adjustment vs A and Active true vs 1 do not false-delta.
 """
 
 from __future__ import annotations
@@ -120,8 +122,10 @@ class TableMapEntry(Model):
 
     Optional ``keys`` / ``fields`` are seed-name → inventory-column aliases
     (V38 M3). Optional ``resolves`` maps seed field → global resolver name
-    (V38 M4): inventory value is looked up id→CD before compare. Absent
-    aliases → identity names. v1 rows are ``{table, entity}`` only.
+    (V38 M4): inventory value is looked up id→CD before compare. Optional
+    ``enums`` maps seed field → global enum table name (V38 M5): seed labels
+    fold to DAC codes before compare. Absent aliases → identity names. v1
+    rows are ``{table, entity}`` only.
     """
 
     table: str
@@ -129,6 +133,7 @@ class TableMapEntry(Model):
     keys: dict[str, str] = Field(default_factory=dict)
     fields: dict[str, str] = Field(default_factory=dict)
     resolves: dict[str, str] = Field(default_factory=dict)
+    enums: dict[str, str] = Field(default_factory=dict)
 
     @field_validator("table", "entity")
     @classmethod
@@ -138,25 +143,25 @@ class TableMapEntry(Model):
             raise ValueError("table/entity must be non-empty")
         return v
 
-    @field_validator("keys", "fields", "resolves", mode="before")
+    @field_validator("keys", "fields", "resolves", "enums", mode="before")
     @classmethod
     def _str_map(cls, v: object) -> object:
-        """Accept seed→inv (or seed→resolver) string maps; reject empty names."""
+        """Accept seed→inv/resolver/enum-name string maps; reject empty names."""
         if v is None:
             return {}
         if not isinstance(v, dict):
-            raise ValueError("keys/fields/resolves must be a mapping of strings")
+            raise ValueError("keys/fields/resolves/enums must be a mapping of strings")
         out: dict[str, str] = {}
         for seed_name, target in v.items():
             s = str(seed_name).strip()
             if isinstance(target, dict):
                 raise ValueError(
-                    f"keys/fields/resolves[{s!r}]: expected string value "
-                    "(use resolves: for FK names; enums are M5)"
+                    f"keys/fields/resolves/enums[{s!r}]: expected string value "
+                    "(use resolves: for FK names; enums: for label->code tables)"
                 )
             i = str(target).strip()
             if not s or not i:
-                raise ValueError("keys/fields/resolves names must be non-empty")
+                raise ValueError("keys/fields/resolves/enums names must be non-empty")
             out[s] = i
         return out
 
@@ -165,6 +170,7 @@ class SnapshotMap(Model):
     """Optional table→entity map (package or data-repo ``snapshot_map.yaml``)."""
 
     resolvers: dict[str, FkResolver] = Field(default_factory=dict)
+    enums: dict[str, dict[str, str]] = Field(default_factory=dict)
     tables: list[TableMapEntry] = Field(default_factory=list)
 
     @field_validator("resolvers", mode="before")
@@ -176,6 +182,39 @@ class SnapshotMap(Model):
             raise ValueError("resolvers must be a mapping of name -> {table,id,cd}")
         return v
 
+    @field_validator("enums", mode="before")
+    @classmethod
+    def _enums_map(cls, v: object) -> object:
+        """Global name → {label: code}; stringify YAML bool keys as true/false."""
+        if v is None:
+            return {}
+        if not isinstance(v, dict):
+            raise ValueError("enums must be a mapping of name -> {label: code}")
+        out: dict[str, dict[str, str]] = {}
+        for name, mapping in v.items():
+            n = str(name).strip()
+            if not n:
+                raise ValueError("enums names must be non-empty")
+            if not isinstance(mapping, dict):
+                raise ValueError(f"enums[{n!r}]: expected mapping of label -> code")
+            inner: dict[str, str] = {}
+            for label, code in mapping.items():
+                if isinstance(label, bool):
+                    lab = "true" if label else "false"
+                else:
+                    lab = str(label).strip()
+                if isinstance(code, bool):
+                    cd = "true" if code else "false"
+                else:
+                    cd = str(code).strip()
+                if not lab or not cd:
+                    raise ValueError(
+                        f"enums[{n!r}]: label/code must be non-empty strings"
+                    )
+                inner[lab] = cd
+            out[n] = inner
+        return out
+
     def entity_for(self, table: str) -> str | None:
         """Catalog entity name for a DAC table, or None when unmapped."""
         entry = self.entry_for(table)
@@ -432,6 +471,7 @@ def reconcile(
     catalog_entities = set(by_entity)
     seed_index = _index_seeds(seeds)
     fk_indexes = _build_fk_indexes(inv, smap.resolvers)
+    enum_tables = smap.enums
     config_present = config_dir is not None and config_dir.is_dir()
 
     unmapped: list[UnmappedTable] = []
@@ -468,6 +508,7 @@ def reconcile(
                 seeds=seed_index,
                 map_entry=map_entry,
                 fk_indexes=fk_indexes,
+                enum_tables=enum_tables,
             )
         )
         _append_usr_custom(custom, table.name, entity, col_names)
@@ -558,7 +599,7 @@ def _rest_gaps_for_table(
     return gaps
 
 
-def _deltas_for_table(  # noqa: PLR0913 — keyword-only; map_entry + fk_indexes V38
+def _deltas_for_table(  # noqa: PLR0913 — keyword-only; map + V38 indexes
     *,
     entity: str,
     table: inventory.TableData,
@@ -567,11 +608,13 @@ def _deltas_for_table(  # noqa: PLR0913 — keyword-only; map_entry + fk_indexes
     seeds: _SeedIndex,
     map_entry: TableMapEntry | None = None,
     fk_indexes: dict[str, dict[str, str]] | None = None,
+    enum_tables: dict[str, dict[str, str]] | None = None,
 ) -> list[FieldDelta]:
     """Per-spec field deltas for one inventory table (optional map aliases)."""
     if not config_present:
         return []
     indexes = fk_indexes if fk_indexes is not None else {}
+    enums = enum_tables if enum_tables is not None else {}
     out: list[FieldDelta] = []
     for spec in specs:
         seed_file = _find_seed_for_spec(spec, seeds)
@@ -585,6 +628,7 @@ def _deltas_for_table(  # noqa: PLR0913 — keyword-only; map_entry + fk_indexes
                 spec=spec,
                 map_entry=map_entry,
                 fk_indexes=indexes,
+                enum_tables=enums,
             )
         )
     return out
@@ -657,6 +701,35 @@ def _resolve_inv_value(
     return id_to_cd.get(raw, raw)
 
 
+def _enum_norm(
+    raw: str,
+    *,
+    field: str,
+    field_enums: dict[str, str],
+    enum_tables: dict[str, dict[str, str]],
+) -> str:
+    """Map REST label → DAC code when field has an enum table (V38 M5).
+
+    Seed side usually carries labels (Adjustment, Asset, true); inventory
+    stores codes (A, A, 1). Labels in the table fold to codes; values that
+    already equal a code (or are unmapped) pass through unchanged.
+    """
+    enum_name = field_enums.get(field)
+    if enum_name is None:
+        return raw
+    table = enum_tables.get(enum_name)
+    if not table:
+        return raw
+    if raw in table:
+        return table[raw]
+    # case-insensitive label match (seed YAML sometimes differs in case)
+    lower = raw.lower()
+    for lab, code in table.items():
+        if lab.lower() == lower:
+            return code
+    return raw
+
+
 def _compare_seed_table(  # noqa: PLR0913 — keyword-only compare bundle
     *,
     entity: str,
@@ -665,6 +738,7 @@ def _compare_seed_table(  # noqa: PLR0913 — keyword-only compare bundle
     spec: extract.EntitySpec,
     map_entry: TableMapEntry | None = None,
     fk_indexes: dict[str, dict[str, str]] | None = None,
+    enum_tables: dict[str, dict[str, str]] | None = None,
 ) -> list[FieldDelta]:
     """Field-level compare for rows that share a key tuple on both sides.
 
@@ -673,8 +747,9 @@ def _compare_seed_table(  # noqa: PLR0913 — keyword-only compare bundle
     → skip that seed row (no false delta). Optional map ``keys`` / ``fields``
     rename seed names → inv columns (V38 M3). Optional ``resolves`` + global
     FK indexes convert inv int IDs → CD before compare (V38 M4; prefer seed
-    CD space). Join keys and field values are pad-trimmed on both sides (V38)
-    so fixed-width / trailing-space DAC columns match seed natural keys.
+    CD space). Optional ``enums`` + global enum tables fold seed labels →
+    codes (V38 M5). Join keys and field values are pad-trimmed on both sides
+    (V38) so fixed-width / trailing-space DAC columns match seed natural keys.
     Detail lists skipped (not comparable to flat snapshot rows). Findings
     always report seed-side field names and resolved inventory values.
     """
@@ -682,7 +757,9 @@ def _compare_seed_table(  # noqa: PLR0913 — keyword-only compare bundle
     key_alias = map_entry.keys if map_entry is not None else {}
     field_alias = map_entry.fields if map_entry is not None else {}
     resolves = map_entry.resolves if map_entry is not None else {}
+    field_enums = map_entry.enums if map_entry is not None else {}
     indexes = fk_indexes if fk_indexes is not None else {}
+    enums = enum_tables if enum_tables is not None else {}
     inv_keys = [key_alias.get(k, k) for k in keys]
     inv_index = _index_inventory_rows(table.rows, inv_keys)
     deltas: list[FieldDelta] = []
@@ -701,12 +778,22 @@ def _compare_seed_table(  # noqa: PLR0913 — keyword-only compare bundle
             inv_field = field_alias.get(field, field)
             if inv_field not in inv_row:
                 continue
-            left = _norm(seed_val)
-            right = _resolve_inv_value(
-                _norm(inv_row[inv_field]),
+            left = _enum_norm(
+                _norm(seed_val),
                 field=field,
-                resolves=resolves,
-                fk_indexes=indexes,
+                field_enums=field_enums,
+                enum_tables=enums,
+            )
+            right = _enum_norm(
+                _resolve_inv_value(
+                    _norm(inv_row[inv_field]),
+                    field=field,
+                    resolves=resolves,
+                    fk_indexes=indexes,
+                ),
+                field=field,
+                field_enums=field_enums,
+                enum_tables=enums,
             )
             if left != right:
                 deltas.append(
@@ -742,21 +829,32 @@ def _norm(value: Any) -> str:
 
     String sides strip leading/trailing whitespace (DAC/NVarChar padding).
     Bools/numbers fold to a stable spelling so seed and inventory agree.
-    Sibling of ``seed._norm`` spirit; used on *both* key join and field
-    compare so padded inventory never misses a seed row or false-deltas.
+    Decimal-looking strings with a point collapse trailing zeros so seed
+    ``0`` matches inventory ``0.000000`` without treating bare CDs like
+    ``000000`` as numbers. Sibling of ``seed._norm`` spirit; used on *both*
+    key join and field compare so padded inventory never misses a seed row
+    or false-deltas.
     """
     if isinstance(value, bool):
-        return "true" if value else "false"
-    if value is None:
-        return ""
-    if isinstance(value, int) and not isinstance(value, bool):
-        return str(value)
-    if isinstance(value, float):
+        s = "true" if value else "false"
+    elif value is None:
+        s = ""
+    elif isinstance(value, int):
+        s = str(value)
+    elif isinstance(value, float):
         as_int = int(value)
-        if value == float(as_int):
-            return str(as_int)
-        return str(value)
-    return str(value).strip()
+        s = str(as_int) if value == float(as_int) else str(value)
+    else:
+        s = str(value).strip()
+        if "." in s:
+            try:
+                f = float(s)
+            except ValueError:
+                return s
+            as_int = int(f)
+            if f == float(as_int):
+                s = str(as_int)
+    return s
 
 
 # ---------------------------------------------------------------------------

{acumatica_cli-0.17.0 → acumatica_cli-0.18.0}/src/acumatica_cli/snapshot_map.yaml

@@ -3,8 +3,9 @@
 # table → catalog entity. Optional keys:/fields: rename seed names →
 # inventory columns so join/compare works when DAC names differ (M3).
 # Global resolvers: + per-row resolves: map inv int FKs → CD (M4).
+# Global enums: + per-row enums: map REST labels → DAC codes (M5).
 # Data-repo root snapshot_map.yaml wins over this package file.
-# v1 rows remain {table, entity} only — aliases/resolves optional.
+# v1 rows remain {table, entity} only — aliases/resolves/enums optional.
 
 resolvers:
   account_cd:
@@ -15,6 +16,37 @@ resolvers:
     table: Sub
     id: SubID
     cd: SubCD
+  branch_cd:
+    table: Branch
+    id: BranchID
+    cd: BranchCD
+
+enums:
+  reason_usage:
+    Adjustment: A
+    Assembly/Disassembly: D
+    Issue: I
+    Receipt: R
+    Vendor Return: N
+  account_type:
+    Asset: A
+    Liability: L
+    Income: I
+    Expense: E
+  post_option:
+    Summary: S
+    Detail: D
+  due_type:
+    Fixed Number of Days: N
+  disc_type:
+    Fixed Number of Days: N
+  visible_to:
+    All: AL
+  prepare_on:
+    Fixed Day of Month: F
+  bool_bit:
+    "true": "1"
+    "false": "0"
 
 tables:
   # Wave 1 renames — key/field aliases where seed ≠ DAC column
@@ -22,8 +54,14 @@ tables:
     entity: Subaccount
     keys:
       SubaccountCD: SubCD
+    enums:
+      Active: bool_bit
   - table: Terms
     entity: CreditTerms
+    enums:
+      DueType: due_type
+      DiscType: disc_type
+      VisibleTo: visible_to
   - table: UnitOfMeasure
     entity: UnitsOfMeasure
     keys:
@@ -34,6 +72,10 @@ tables:
     entity: AvailabilityCalculationRule
   - table: SOSetup
     entity: SOPreferences
+    enums:
+      AutoReleaseIN: bool_bit
+      HoldShipments: bool_bit
+      RequireShipmentTotal: bool_bit
   - table: POSetup
     entity: POPreferences
   - table: ARSetup
@@ -41,13 +83,28 @@ tables:
   - table: APSetup
     entity: APPreferences
 
-  # Wave 2 — table renames (field aliases / more FKs later)
+  # Wave 2 — table renames + PostingClass FK resolve
   - table: INPostClass
     entity: PostingClass
+    resolves:
+      COGSAcctID: account_cd
+      COGSSubID: sub_cd
+      InvtAcctID: account_cd
+      InvtSubID: sub_cd
+      LCVarianceAcctID: account_cd
+      LCVarianceSubID: sub_cd
+      POAccrualAcctID: account_cd
+      POAccrualSubID: sub_cd
+      PPVAcctID: account_cd
+      PPVSubID: sub_cd
+      SalesAcctID: account_cd
+      SalesSubID: sub_cd
   - table: INItemClass
     entity: ItemClass
   - table: INSite
     entity: Warehouse
+    enums:
+      Active: bool_bit
   - table: InventoryItem
     entity: StockItem
   - table: INSetup
@@ -62,17 +119,33 @@ tables:
     entity: KitSpecification
   - table: SOOrderType
     entity: OrderType
+    resolves:
+      FreightAcctID: account_cd
+      FreightSubID: sub_cd
+    enums:
+      Active: bool_bit
   - table: ARStatementCycle
     entity: StatementCycle
+    enums:
+      PrepareOn: prepare_on
   - table: OrganizationLedgerLink
     entity: LedgerCompany
 
-  # Identity tables needing FK CD resolve (M4) — table name == entity
+  # Identity tables — FK resolve (M4) + enums (M5)
+  - table: Account
+    entity: Account
+    enums:
+      Type: account_type
+      PostOption: post_option
+      Active: bool_bit
+      RequireUnits: bool_bit
   - table: ReasonCode
     entity: ReasonCode
     resolves:
       AccountID: account_cd
       SubID: sub_cd
+    enums:
+      Usage: reason_usage
   - table: VendorClass
     entity: VendorClass
     resolves:
@@ -84,3 +157,11 @@ tables:
       ExpenseSubID: sub_cd
       POAccrualAcctID: account_cd
       POAccrualSubID: sub_cd
+  - table: CashAccount
+    entity: CashAccount
+    resolves:
+      AccountID: account_cd
+      SubID: sub_cd
+      BranchID: branch_cd
+    enums:
+      Active: bool_bit