icedcoffee-sync 0.1.0.dev5__py3-none-any.whl

icedcoffee_sync/apply/execute.py

@@ -0,0 +1,180 @@
+"""Turn a ChartPlan into requests, in the only order that works.
+
+Renumbers run before creates: a new account links to its parent by the
+parent's *document name*, and a renumber changes that name, so creating
+first would link a child to a name about to stop existing.
+
+Renumbers need their own order among themselves too -- measured live,
+renumbering "Current Assets" to 1100 before "Cash In Hand" (still sitting on
+1100) vacated it died with a plain "number already used" error.
+`icedcoffee_sync.apply.order.order_renames` works out that order, inserting a park
+step onto a temporary number when two or more renames form a genuine cycle.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, Protocol
+
+from icedcoffee_sync.apply.diff import ChartPlan, RenameAccount
+from icedcoffee_sync.apply.model import DesiredAccount, LiveAccount
+from icedcoffee_sync.apply.order import ParkStep, order_creates, order_renames
+from icedcoffee_sync.erpnext.accounts import document_name
+
+RENUMBER_METHOD = "erpnext.accounts.doctype.account.account.update_account_number"
+
+
+class PlanRefusedError(RuntimeError):
+    """The plan carried refusals; raised before the first request so nothing runs partially applied."""
+
+
+class _Writer(Protocol):
+    def insert(self, doctype: str, doc: dict[str, Any], /) -> Any: ...
+    def update(self, doctype: str, name: str, doc: dict[str, Any], /) -> Any: ...
+    def call(self, dotted_path: str, params: dict[str, Any] | None = None, /) -> Any: ...
+
+
+@dataclasses.dataclass
+class ApplyReport:
+    """What actually happened, for printing back to the operator.
+
+    `parked` is every account `order_renames` moved out of the way to
+    break a renumbering cycle -- distinct from `renamed`, the moves the
+    chart wanted. A parked account's real renumber still lands in `renamed` too.
+    """
+
+    created: list[str] = dataclasses.field(default_factory=list)
+    renamed: list[tuple[str, str]] = dataclasses.field(default_factory=list)
+    parked: list[tuple[str, str, str]] = dataclasses.field(default_factory=list)
+    retyped: list[str] = dataclasses.field(default_factory=list)
+    enabled: list[str] = dataclasses.field(default_factory=list)
+
+
+def _execute_renames(
+    client: _Writer,
+    renames: list[RenameAccount],
+    abbr: str,
+    report: ApplyReport,
+    chart_numbers: frozenset[str],
+    taken: frozenset[str],
+) -> dict[str, str]:
+    """Run every renumber, and any park step `order_renames` had to insert, in order.
+
+    A parked account's document name changes twice -- to its temporary
+    number, then its real one -- so `current_name` tracks each renamed
+    account's *current* document name (keyed by its original one) rather
+    than trusting `RenameAccount.live.document_name`, which only ever
+    holds the pre-run name.
+
+    Returns:
+        The same desired-number -> final-document-name map `apply_chart`
+        threads through creates and retypes.
+    """
+    resolved: dict[str, str] = {}
+    current_name: dict[str, str] = {}
+
+    def name_of(live: LiveAccount) -> str:
+        return current_name.get(live.document_name, live.document_name)
+
+    for step in order_renames(renames, chart_numbers, taken):
+        if isinstance(step, ParkStep):
+            new_name = client.call(
+                RENUMBER_METHOD,
+                {
+                    "name": name_of(step.live),
+                    "account_name": step.live.name,
+                    "account_number": step.temporary_number,
+                },
+            )
+            new_name = (
+                str(new_name)
+                if new_name
+                else _swap_leading_number(step.live.document_name, step.live.number, step.temporary_number)
+            )
+            current_name[step.live.document_name] = new_name
+            report.parked.append((step.live.document_name, step.temporary_number, new_name))
+            continue
+
+        new_name = client.call(
+            RENUMBER_METHOD,
+            {
+                "name": name_of(step.live),
+                "account_name": step.desired.name,
+                "account_number": step.desired.number,
+            },
+        )
+        new_name = str(new_name) if new_name else document_name(step.desired.name, abbr, step.desired.number)
+        resolved[step.desired.number] = new_name
+        report.renamed.append((step.live.document_name, new_name))
+
+    return resolved
+
+
+def _swap_leading_number(old_document_name: str, old_number: str, new_number: str) -> str:
+    """Fallback when the server returns no name: swap just the leading number.
+
+    A document name is `"{number} - {name} - {abbr}"`; only the number
+    changed, so replacing that leading prefix reproduces it without the
+    abbreviation as a separate input (mirrors `icedcoffee_sync.apply.park`'s
+    identical fallback).
+    """
+    return old_document_name.replace(f"{old_number} - ", f"{new_number} - ", 1)
+
+
+def apply_chart(
+    client: _Writer,
+    plan: ChartPlan,
+    live: list[LiveAccount],
+    by_number: dict[str, DesiredAccount],
+    abbr: str,
+    company: str,
+) -> ApplyReport:
+    """Execute a plan. Raises PlanRefusedError before touching anything if it was refused.
+
+    `live` is the whole pre-diff live chart, not just the accounts `plan`
+    singles out: an account `plan` never mentions can still already hold a
+    number `order_renames` might otherwise pick to park something onto.
+    """
+    if plan.refusals:
+        reasons = ", ".join(sorted({r.reason.value for r in plan.refusals}))
+        raise PlanRefusedError(f"plan carries {len(plan.refusals)} refusal(s): {reasons}")
+
+    chart_numbers = frozenset(by_number)
+    taken = frozenset(a.number for a in live if a.number)
+    report = ApplyReport()
+    resolved = _execute_renames(client, plan.renames, abbr, report, chart_numbers, taken)
+
+    for change in order_creates(plan.creates, by_number):
+        want = change.desired
+        parent_name: str | None = None
+        if want.parent_number is not None:
+            parent = by_number[want.parent_number]
+            parent_name = resolved.get(want.parent_number, document_name(parent.name, abbr, parent.number))
+        doc: dict[str, Any] = {
+            "account_name": want.name,
+            "account_number": want.number,
+            "company": company,
+            "is_group": 1 if want.is_group else 0,
+            "root_type": want.root_type,
+        }
+        if parent_name is not None:
+            doc["parent_account"] = parent_name
+        if want.account_type:
+            doc["account_type"] = want.account_type
+        created = client.insert("Account", doc)
+        created_name = created.get("name") if isinstance(created, dict) else None
+        created_name = created_name or document_name(want.name, abbr, want.number)
+        resolved[want.number] = created_name
+        report.created.append(created_name)
+
+    for change in plan.retypes:
+        target = resolved.get(change.desired.number, change.live.document_name)
+        client.update("Account", target, {"account_type": change.desired.account_type or ""})
+        report.retyped.append(target)
+
+    for change in plan.enables:
+        target = resolved.get(change.desired.number, change.live.document_name)
+        client.update("Account", target, {"disabled": 0})
+        report.enabled.append(target)
+
+    return report

icedcoffee_sync/apply/model.py

@@ -0,0 +1,45 @@
+"""What the chart wants, and what the site currently has.
+
+Neither record carries a match key. Matching the two is a tree walk
+(`icedcoffee_sync.apply.diff`), because an account has no usable intrinsic identity: a
+name repeats across the chart ("Accounts Payable" is both a group and a leaf
+inside it), and the number is the thing most likely to be absent or changing --
+a site set up through ERPNext's wizard has no numbers at all. What identifies
+an account is where it sits: which root it hangs under, then its account name
+among that parent's actual children.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+type MatchKey = tuple[str, str | None]
+"""How a refusal names the account it is about: (account name, parent name)."""
+
+
+@dataclasses.dataclass(frozen=True)
+class DesiredAccount:
+    """One account as the chart file describes it."""
+
+    number: str
+    name: str
+    parent_number: str | None
+    is_group: bool
+    root_type: str
+    account_type: str | None = None
+
+
+@dataclasses.dataclass(frozen=True)
+class LiveAccount:
+    """One account as the site currently has it."""
+
+    document_name: str
+    number: str
+    name: str
+    parent_document_name: str | None
+    is_group: bool
+    root_type: str
+    account_type: str | None = None
+    # Defaults False so every existing construction site -- test fixtures
+    # included -- keeps working unchanged; only icedcoffee_sync.apply.prune reads it.
+    disabled: bool = False

icedcoffee_sync/apply/order.py

@@ -0,0 +1,129 @@
+"""Order changes so each one can actually be executed when its turn comes.
+
+ERPNext links a new account to its parent's *document name*, so the parent
+must exist first: creates run shallowest-first, and every renumber runs
+before any create. Renumbers also need their own order among themselves --
+measured live, "Current Assets" taking 1100 before "Cash In Hand" vacated it
+died with "number already used", a collision `ChartPlan` deliberately leaves
+for `order_renames` to resolve rather than refusing outright.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+from icedcoffee_sync.apply.diff import CreateAccount, RenameAccount
+from icedcoffee_sync.apply.model import DesiredAccount, LiveAccount
+from icedcoffee_sync.apply.park import _next_candidate
+
+
+class CyclicChartError(ValueError):
+    """A chart whose parent links form a loop."""
+
+
+def depth(account: DesiredAccount, by_number: dict[str, DesiredAccount]) -> int:
+    """How many ancestors an account has. Raises on a cycle or dangling parent."""
+    seen: list[str] = [account.number]
+    steps = 0
+    current = account
+    while current.parent_number is not None:
+        if current.parent_number in seen:
+            raise CyclicChartError(f"parent cycle through {' -> '.join([*seen, current.parent_number])}")
+        seen.append(current.parent_number)
+        parent = by_number.get(current.parent_number)
+        if parent is None:
+            raise KeyError(f"account {current.number} names parent {current.parent_number}, which is not in the chart")
+        current = parent
+        steps += 1
+    return steps
+
+
+def order_creates(creates: list[CreateAccount], by_number: dict[str, DesiredAccount]) -> list[CreateAccount]:
+    """Shallowest first, preserving chart order within a depth -- a stable sort, since depth is a valid tree order."""
+    return sorted(creates, key=lambda c: depth(c.desired, by_number))
+
+
+@dataclasses.dataclass(frozen=True)
+class ParkStep:
+    """A temporary renumber, not a chart member, that frees `live`'s number for whoever is waiting on it."""
+
+    live: LiveAccount
+    temporary_number: str
+
+
+type RenameStep = RenameAccount | ParkStep
+
+
+def order_renames(
+    renames: list[RenameAccount], chart_numbers: frozenset[str], taken: frozenset[str]
+) -> list[RenameStep]:
+    """Order renames so none tries to claim a number still occupied by another.
+
+    Renumber X depends on renumber Y when `X.desired.number ==
+    Y.live.number`; `ChartPlan` deliberately leaves that unrefused, so a
+    topological sort must resolve it, breaking a genuine cycle by parking
+    its lowest-indexed member onto a temporary number.
+
+    Args:
+        chart_numbers: Every account number the chart describes.
+        taken: Every number occupied on the live site, including accounts
+            this plan does not touch.
+
+    Returns:
+        `renames`, reordered, with a `ParkStep` wherever a cycle was broken.
+    """
+    n = len(renames)
+    dependents, remaining = _dependency_graph(renames)
+    avoid = taken | chart_numbers
+
+    done: set[int] = set()
+    vacated: set[int] = set()
+    parked_at: set[str] = set()
+    steps: list[RenameStep] = []
+
+    def _next_ready() -> int | None:
+        return next((i for i in range(n) if i not in done and remaining[i] == 0), None)
+
+    def _vacate(i: int) -> None:
+        vacated.add(i)
+        for dependent in dependents[i]:
+            remaining[dependent] -= 1
+
+    while len(done) < n:
+        ready = _next_ready()
+        if ready is not None:
+            steps.append(renames[ready])
+            done.add(ready)
+            _vacate(ready)
+            continue
+
+        # A cycle: park the lowest-indexed unvacated member to free its number.
+        to_park = next(i for i in range(n) if i not in vacated)
+        candidate = _unused_number(renames[to_park].live.number, avoid | parked_at)
+        parked_at.add(candidate)
+        steps.append(ParkStep(renames[to_park].live, candidate))
+        _vacate(to_park)
+
+    return steps
+
+
+def _dependency_graph(renames: list[RenameAccount]) -> tuple[list[set[int]], list[int]]:
+    """Which renames must run before which, and how many each is still waiting on."""
+    n = len(renames)
+    depends_on = [
+        {j for j in range(n) if j != i and renames[i].desired.number == renames[j].live.number} for i in range(n)
+    ]
+    dependents: list[set[int]] = [set() for _ in range(n)]
+    for i, deps in enumerate(depends_on):
+        for j in deps:
+            dependents[j].add(i)
+    remaining = [len(deps) for deps in depends_on]
+    return dependents, remaining
+
+
+def _unused_number(number: str, avoid: frozenset[str] | set[str]) -> str:
+    """`number`, escalated with `_next_candidate` until it names nothing in `avoid`."""
+    candidate = _next_candidate(number)
+    while candidate in avoid:
+        candidate = _next_candidate(candidate)
+    return candidate

icedcoffee_sync/apply/park.py

@@ -0,0 +1,107 @@
+"""Move a surviving account's number out of the chart's way, without deleting it.
+
+ERPNext refills four Company defaults (income, write-off, exchange gain/loss,
+asset disposal) by account name on every Company save and refuses to retire
+a default, so some pre-existing accounts cannot go before apply has pointed
+the defaults elsewhere -- yet apply cannot create the chart's account on a
+number they hold. Parking renumbers the survivor (9-prefixed) so apply can
+run; the closing prune retires it afterwards.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, Protocol
+
+from icedcoffee_sync.apply.model import LiveAccount
+from icedcoffee_sync.apply.prune import PruneReason, PruneRefusal, PruneReport
+
+# The whitelisted rename apply itself uses; a field update does not move the document.
+RENUMBER_METHOD = "erpnext.accounts.doctype.account.account.update_account_number"
+
+
+@dataclasses.dataclass(frozen=True)
+class ParkedNumber:
+    """One survivor renumbered out of the chart's way."""
+
+    old_document_name: str
+    number: str
+    parked_number: str
+    new_document_name: str
+
+
+class _Client(Protocol):
+    def call(self, dotted_path: str, params: dict[str, Any] | None = None) -> Any: ...
+
+
+def _next_candidate(number: str) -> str:
+    """One more `9` prepended -- the escalation `park_colliding_numbers` retries with."""
+    return f"9{number}"
+
+
+def park_colliding_numbers(
+    client: _Client,
+    survivors: list[LiveAccount],
+    chart_numbers: frozenset[str],
+    taken: frozenset[str],
+) -> list[ParkedNumber]:
+    """Renumber every non-root survivor holding a chart number onto a free 9-prefixed one.
+
+    Roots are skipped: apply matches them by root type and renames them
+    itself. `taken` is every number occupied on the site; the chosen number
+    also avoids `chart_numbers` and earlier picks. Only the number moves.
+    """
+    parked: list[ParkedNumber] = []
+    chosen: set[str] = set()
+    for survivor in survivors:
+        if survivor.parent_document_name is None:
+            continue
+        if survivor.number not in chart_numbers:
+            continue
+
+        candidate = _next_candidate(survivor.number)
+        while candidate in taken or candidate in chart_numbers or candidate in chosen:
+            candidate = _next_candidate(candidate)
+        chosen.add(candidate)
+
+        new_name = client.call(
+            RENUMBER_METHOD,
+            {
+                "name": survivor.document_name,
+                "account_name": survivor.name,
+                "account_number": candidate,
+            },
+        )
+        # Document names are "{number} - {name} - {abbr}"; only the number changed.
+        new_name = (
+            str(new_name) if new_name else survivor.document_name.replace(f"{survivor.number} - ", f"{candidate} - ", 1)
+        )
+        parked.append(ParkedNumber(survivor.document_name, survivor.number, candidate, new_name))
+    return parked
+
+
+def parking_candidates(
+    extras: list[LiveAccount],
+    report: PruneReport,
+    refusals: list[PruneRefusal],
+) -> tuple[list[LiveAccount], list[LiveAccount]]:
+    """Split prune's survivors into `(candidates, gl_excluded)`.
+
+    Candidates are the extras the run could not retire plus those refused
+    for any reason but GL entries -- renumbering never touches ledger
+    history, so a live child or root status is no obstacle. Extras refused
+    for GL entries are returned separately so the caller can still report
+    them as unresolved collisions.
+    """
+    gl_excluded = [refusal.live for refusal in refusals if refusal.reason is PruneReason.HAS_GL_ENTRIES]
+    survivor_names = set(report.disabled) | set(report.already_disabled) | {name for name, _ in report.failed}
+    survivor_names |= {
+        refusal.live.document_name for refusal in refusals if refusal.reason is not PruneReason.HAS_GL_ENTRIES
+    }
+    candidates = [extra for extra in extras if extra.document_name in survivor_names]
+    return candidates, gl_excluded
+
+
+def unresolved_collisions(excluded: list[LiveAccount], chart_numbers: frozenset[str]) -> list[str]:
+    """Document names of the non-root `excluded` accounts still holding a chart number -- a failure to report."""
+    return [a.document_name for a in excluded if a.parent_document_name is not None and a.number in chart_numbers]

icedcoffee_sync/apply/prune.py

@@ -0,0 +1,215 @@
+"""Delete accounts the chart does not describe.
+
+The only operation here that destroys data, against a real ledger. A
+`PruneRefusal` is per-account, not plan-wide like `diff`'s `Refusal`: a
+declined account is just an extra again next time and must not block its
+siblings.
+
+`plan_prune` refuses only what it knows locally, leaving referential
+integrity to ERPNext's own `LinkExistsError`. Some accounts ERPNext names
+disable as the only alternative; `execute_prune` falls back to disable on
+that error, `ValidationError`, or `ChildExistsError` only.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import enum
+from typing import Any, Protocol
+
+from icedcoffee_sync.apply.model import LiveAccount
+from icedcoffee_sync.frappe.errors import ChildExistsError, FrappeError, LinkExistsError, ValidationError
+
+
+class PruneReason(enum.StrEnum):
+    """Why an extra account was not put on the delete list."""
+
+    HAS_GL_ENTRIES = "has_gl_entries"
+    IS_ROOT = "is_root"
+    HAS_LIVE_CHILD = "has_live_child"
+
+
+@dataclasses.dataclass(frozen=True)
+class DeleteAccount:
+    """An extra account cleared to delete."""
+
+    live: LiveAccount
+
+
+@dataclasses.dataclass(frozen=True)
+class PruneRefusal:
+    """One extra account pruning will not touch, and why."""
+
+    live: LiveAccount
+    reason: PruneReason
+    detail: str
+
+
+@dataclasses.dataclass(frozen=True)
+class PrunePlan:
+    """What `plan_prune` concluded: deletes in execution order, plus refusals."""
+
+    deletes: list[DeleteAccount]
+    refusals: list[PruneRefusal]
+
+    @property
+    def is_empty(self) -> bool:
+        """True when there is nothing to prune and nothing to report."""
+        return not (self.deletes or self.refusals)
+
+
+def plan_prune(
+    extras: list[LiveAccount],
+    live: list[LiveAccount],
+    accounts_with_entries: set[str],
+) -> PrunePlan:
+    """Decide which extras may be deleted, deepest first.
+
+    An extra already disabled is re-attempted, since whatever blocked it
+    might not still apply. Refused rather than deleted when it carries
+    ledger entries (per `accounts_with_entries`, a snapshot from plan time),
+    is a root (only ever matched, never created or removed), or still has a
+    live child -- checked against which children actually cleared, not mere
+    presence in `extras`, which is why extras are decided deepest first.
+    """
+    by_document_name = {account.document_name: account for account in live}
+
+    live_children: dict[str, list[LiveAccount]] = {}
+    for account in live:
+        if account.parent_document_name is not None:
+            live_children.setdefault(account.parent_document_name, []).append(account)
+
+    deletable: list[LiveAccount] = []
+    deletable_names: set[str] = set()
+    refusals: list[PruneRefusal] = []
+
+    # Deepest first: a parent's eligibility depends on its own extra children.
+    ordered_extras = sorted(extras, key=lambda account: _depth(account, by_document_name), reverse=True)
+
+    for account in ordered_extras:
+        if account.document_name in accounts_with_entries:
+            refusals.append(
+                PruneRefusal(
+                    account,
+                    PruneReason.HAS_GL_ENTRIES,
+                    f"{account.document_name} carries ledger entries and cannot be deleted",
+                )
+            )
+            continue
+
+        if account.parent_document_name is None:
+            refusals.append(
+                PruneRefusal(
+                    account,
+                    PruneReason.IS_ROOT,
+                    f"{account.document_name} is a root; ERPNext requires exactly one root per "
+                    f"root_type and a root can only be matched, never created or deleted",
+                )
+            )
+            continue
+
+        # A child survives unless it already cleared to delete -- checked
+        # against `deletable_names`, not mere presence in `extras`.
+        surviving_children = [
+            child.document_name
+            for child in live_children.get(account.document_name, [])
+            if child.document_name not in deletable_names
+        ]
+        if surviving_children:
+            found = ", ".join(surviving_children)
+            refusals.append(
+                PruneRefusal(
+                    account,
+                    PruneReason.HAS_LIVE_CHILD,
+                    f"{account.document_name} still has a live child not being deleted: {found}",
+                )
+            )
+            continue
+
+        deletable.append(account)
+        deletable_names.add(account.document_name)
+
+    ordered = sorted(deletable, key=lambda account: _depth(account, by_document_name), reverse=True)
+    return PrunePlan([DeleteAccount(account) for account in ordered], refusals)
+
+
+def _depth(account: LiveAccount, by_document_name: dict[str, LiveAccount]) -> int:
+    """How many ancestors an account has. Gives up on a cycle rather than hanging."""
+    seen: set[str] = {account.document_name}
+    steps = 0
+    current = account
+    while current.parent_document_name is not None:
+        if current.parent_document_name in seen:
+            break
+        parent = by_document_name.get(current.parent_document_name)
+        if parent is None:
+            break
+        seen.add(parent.document_name)
+        current = parent
+        steps += 1
+    return steps
+
+
+class _Client(Protocol):
+    """The slice of Client a prune execution needs."""
+
+    def delete(self, doctype: str, name: str, /) -> Any: ...
+    def update(self, doctype: str, name: str, doc: dict[str, Any], /) -> Any: ...
+
+
+@dataclasses.dataclass
+class PruneReport:
+    """What happened. `disabled` is a fresh fallback disable; `already_disabled` came in disabled and stayed refused."""
+
+    deleted: list[str] = dataclasses.field(default_factory=list)
+    disabled: list[str] = dataclasses.field(default_factory=list)
+    already_disabled: list[str] = dataclasses.field(default_factory=list)
+    failed: list[tuple[str, str]] = dataclasses.field(default_factory=list)
+
+
+# FrappeError subclasses meaning ERPNext refused a delete on business
+# grounds; anything else (RateLimitError, an unclassified 5xx) is
+# infrastructure trouble that propagates instead.
+_DISABLE_ELIGIBLE: tuple[type[FrappeError], ...] = (LinkExistsError, ValidationError, ChildExistsError)
+
+
+def execute_prune(client: _Client, plan: PrunePlan) -> PruneReport:
+    """Delete each planned account in order, falling back to disable, continuing past a failure.
+
+    A delete refused with a `_DISABLE_ELIGIBLE` class falls back to
+    disabling instead; a disable failing the same way is recorded `failed`.
+    Neither ends the run. An account already disabled coming in is still
+    attempted, and if refused again is reported `already_disabled` with no
+    redundant disable.
+
+    Raises:
+        FrappeError: A delete or its disable fallback failed with something
+            outside `_DISABLE_ELIGIBLE`.
+    """
+    report = PruneReport()
+    for change in plan.deletes:
+        name = change.live.document_name
+        try:
+            client.delete("Account", name)
+        except _DISABLE_ELIGIBLE:
+            if change.live.disabled:
+                report.already_disabled.append(name)
+            else:
+                _fall_back_to_disable(client, name, report)
+        else:
+            report.deleted.append(name)
+    return report
+
+
+def _fall_back_to_disable(client: _Client, name: str, report: PruneReport) -> None:
+    """Disable an account whose delete just failed, recording the outcome.
+
+    Catches only `_DISABLE_ELIGIBLE`, symmetric with the delete attempt;
+    anything else propagates uncaught the same way.
+    """
+    try:
+        client.update("Account", name, {"disabled": 1})
+    except _DISABLE_ELIGIBLE as error:
+        report.failed.append((name, str(error)))
+    else:
+        report.disabled.append(name)

icedcoffee_sync/erpnext/__init__.py

@@ -0,0 +1 @@
+"""ERPNext doctype knowledge layered over the generic Frappe client."""