lambda-erp 0.2.0__tar.gz → 0.2.2__tar.gz

{lambda_erp-0.2.0 → lambda_erp-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lambda-erp
-Version: 0.2.0
+Version: 0.2.2
 Summary: Core ERP logic - accounting, sales, purchasing, inventory
 Author: TORUS INVESTMENTS AG
 License-Expression: MIT

{lambda_erp-0.2.0 → lambda_erp-0.2.2}/api/chat.py

@@ -1081,6 +1081,11 @@ TOOLS = [
                 "applying). Call this first, walk the user through the plan and the big "
                 "decisions in plain language, and only call `apply_company_setup` once they "
                 "confirm.\n\n"
+                "It also returns an `existing` block: if `existing.company_exists` is true, tell "
+                "the user up front that the company already exists — setup will only add what's "
+                "missing and leave the rest. If `existing.needs_confirmation` is true (already "
+                "configured, or a currency/jurisdiction mismatch), surface `existing.advisory` as "
+                "a clear warning before proceeding.\n\n"
                 "`sector` is one of: services, retail_pos, hospitality, distribution, "
                 "import_export, manufacturing, construction. If you're unsure which fits, "
                 "ASK the user about their business rather than guessing. `country` selects "
@@ -1112,12 +1117,21 @@ TOOLS = [
         "function": {
             "name": "apply_company_setup",
             "description": (
-                "CREATE the company, its chart of accounts (base + sector overlay), the "
-                "company default accounts, any jurisdiction tax accounts, and the default "
-                "cost center — in one step. Only call this AFTER `plan_company_setup` and "
-                "AFTER the user has explicitly confirmed the plan and any big decisions. "
-                "Refuses if the company already has accounts (admin-only). Pass the SAME "
-                "arguments you used for the plan the user approved."
+                "CREATE/converge the company, its chart of accounts (base + sector overlay), "
+                "the company default accounts, any jurisdiction tax templates, and the default "
+                "cost center — in one step. Only call AFTER `plan_company_setup` and AFTER the "
+                "user has confirmed the plan and any big decisions. Pass the SAME arguments you "
+                "used for the approved plan.\n\n"
+                "This is idempotent and safe to run alongside an existing deployment: it only "
+                "adds accounts that are missing, fills only empty defaults, and never modifies "
+                "or deletes existing data. The result is a reconciliation report "
+                "(accounts_created vs accounts_skipped, defaults_set vs defaults_left_untouched) "
+                "— relay it plainly.\n\n"
+                "GUARDRAIL: if the company is already configured, or its currency differs from "
+                "this setup, the call returns `{ok:false, needs_confirmation:true, advisory}` "
+                "instead of proceeding. In that case, WARN the user clearly using the advisory "
+                "(especially a currency/jurisdiction mismatch, which mixes two charts), and only "
+                "re-call with `confirm_existing=true` if the user explicitly insists."
             ),
             "parameters": {
                 "type": "object",
@@ -1131,6 +1145,11 @@ TOOLS = [
                     "country": {"type": "string"},
                     "variant": {"type": "string"},
                     "currency": {"type": "string"},
+                    "confirm_existing": {
+                        "type": "boolean",
+                        "description": "Set true ONLY to proceed after a needs_confirmation "
+                                       "response and the user has insisted despite the warning.",
+                    },
                 },
                 "required": ["name"],
             },
@@ -1677,6 +1696,7 @@ def _handle_apply_company_setup(args):
         variant=(args.get("variant") or None),
         sector=(args.get("sector") or None),
         currency=(args.get("currency") or None),
+        confirm_existing=bool(args.get("confirm_existing")),
     )
 
 
@@ -1857,6 +1877,8 @@ When the user wants to **set up a new company**, get started, or create their bo
 3. **Walk them through the plan** in plain language: the sector-specific accounts (`sector_added_accounts`) and the `sector.guidance` (why the chart is shaped this way). Present every item in `sector.big_decisions` and get an explicit yes/no on each — these are the decisions you must not make for them.
 4. **Only after they confirm, call `apply_company_setup`** with the SAME arguments to create the company, accounts, defaults, and cost center.
 If `jurisdiction.is_fallback` is true, tell the user their country isn't localized yet and you're using the generic international chart for now.
+
+**Existing companies.** Setup is idempotent — it adds only missing accounts, fills only empty defaults, and never modifies or deletes existing data, so it runs safely alongside an existing deployment. Use the `existing` block the plan returns: if the company already exists, say so up front ("it already exists — I'll add what's missing and leave the rest"). If `apply_company_setup` returns `needs_confirmation` (the company is already configured, or the currency/jurisdiction differs and would mix two charts), do NOT force it — relay the `advisory` as a clear warning and re-call with `confirm_existing: true` only if the user explicitly insists. After applying, relay the reconciliation report plainly (how many accounts were created vs already present).
 """
     else:
         company_setup_section = ""

{lambda_erp-0.2.0 → lambda_erp-0.2.2}/lambda_erp/accounting/chart_of_accounts.py

@@ -147,6 +147,8 @@ def create_accounts_from_tree(company_name, tree, currency="USD"):
     Does NOT commit — the caller owns the transaction boundary.
     """
     db = get_db()
+    created: list[str] = []
+    skipped: list[str] = []
 
     def _create(subtree, parent=None, root_type=None, report_type=None):
         for account_name, details in subtree.items():
@@ -156,36 +158,59 @@ def create_accounts_from_tree(company_name, tree, currency="USD"):
 
             name = f"{account_name} - {account_abbr(company_name)}"
 
-            account = _dict(
-                name=name,
-                account_name=account_name,
-                parent_account=parent,
-                company=company_name,
-                root_type=rt,
-                report_type=rpt,
-                account_type=details.get("account_type", ""),
-                account_currency=currency,
-                is_group=1 if has_children else 0,
-            )
-            db.insert("Account", account)
+            # Idempotent: skip an account that already exists rather than failing
+            # on the primary key. Lets setup run alongside an existing deployment
+            # and fill in only what's missing. Recursion into children still runs
+            # so a partially-built chart converges to complete.
+            if db.exists("Account", name):
+                skipped.append(name)
+            else:
+                db.insert("Account", _dict(
+                    name=name,
+                    account_name=account_name,
+                    parent_account=parent,
+                    company=company_name,
+                    root_type=rt,
+                    report_type=rpt,
+                    account_type=details.get("account_type", ""),
+                    account_currency=currency,
+                    is_group=1 if has_children else 0,
+                ))
+                created.append(name)
 
             if has_children:
                 _create(details["children"], parent=name, root_type=rt, report_type=rpt)
 
     _create(tree)
+    return {"created": created, "skipped": skipped}
 
 
 def apply_company_defaults(company_name, defaults):
-    """Point Company default-account fields at the created leaf accounts.
+    """Point Company default-account fields at their leaf accounts.
 
     ``defaults`` is ``{company_field: leaf_account_name}`` (un-suffixed); the
-    company suffix is appended here. Does NOT commit.
+    company suffix is appended here. **Fill-only-empty:** a field already set is
+    left untouched (never clobber a configured company). A target account that
+    doesn't exist is skipped (never point a default at a missing account). Does
+    NOT commit. Returns ``{"set", "left", "missing"}``.
     """
     abbr = account_abbr(company_name)
-    resolved = {field: f"{leaf} - {abbr}" for field, leaf in defaults.items()}
-    if resolved:
-        db = get_db()
-        db.set_value("Company", company_name, resolved)
+    db = get_db()
+    to_set: dict[str, str] = {}
+    result = {"set": [], "left": [], "missing": []}
+    for field, leaf in defaults.items():
+        if db.get_value("Company", company_name, field):
+            result["left"].append(field)          # already configured — keep it
+            continue
+        target = f"{leaf} - {abbr}"
+        if not db.exists("Account", target):
+            result["missing"].append((field, target))
+            continue
+        to_set[field] = target
+        result["set"].append(field)
+    if to_set:
+        db.set_value("Company", company_name, to_set)
+    return result
 
 
 def setup_chart_of_accounts(company_name, currency="USD"):
@@ -204,16 +229,23 @@ def setup_chart_of_accounts(company_name, currency="USD"):
 
 
 def setup_cost_center(company_name):
-    """Create default cost center for a company."""
+    """Create the default cost center for a company (idempotent).
+
+    Skips creation if it already exists, and fills the cost-center company
+    defaults only when empty, so it is safe to run alongside an existing setup.
+    """
     db = get_db()
     name = f"Main - {company_name[:4].upper()}"
-    db.insert("Cost Center", _dict(
-        name=name,
-        cost_center_name="Main",
-        company=company_name,
-        is_group=0,
-    ))
-    db.set_value("Company", company_name, "default_cost_center", name)
-    db.set_value("Company", company_name, "round_off_cost_center", name)
+    if not db.exists("Cost Center", name):
+        db.insert("Cost Center", _dict(
+            name=name,
+            cost_center_name="Main",
+            company=company_name,
+            is_group=0,
+        ))
+    if not db.get_value("Company", company_name, "default_cost_center"):
+        db.set_value("Company", company_name, "default_cost_center", name)
+    if not db.get_value("Company", company_name, "round_off_cost_center"):
+        db.set_value("Company", company_name, "round_off_cost_center", name)
     db.commit()
     return name

{lambda_erp-0.2.0 → lambda_erp-0.2.2}/lambda_erp/accounting/setup/engine.py

@@ -66,12 +66,27 @@ def _attach(tree: dict, parent_name: str, overlay_acct: dict) -> bool:
     return True
 
 
+def _localize_name(acct: dict, language: str) -> str:
+    """The overlay account's name in the pack's language, English otherwise.
+
+    Profiles carry a jurisdiction-neutral English ``name`` plus an ``i18n`` map
+    ({lang: name}); on a German (Swiss) chart the German name is used so the
+    overlay reads in the same language as the base chart.
+    """
+    if language and language != "en":
+        localized = (acct.get("i18n") or {}).get(language)
+        if localized:
+            return localized
+    return acct["name"]
+
+
 def _merge(pack: LocalizationPack, profile: Optional[SectorProfile]):
     """Return ``(merged_tree, merged_defaults, added_names, skipped)``.
 
-    ``added_names`` are the overlay accounts actually attached; ``skipped`` are
-    overlay accounts whose anchor was unmapped or whose name collided — surfaced
-    so a mis-wired profile/pack pairing is visible rather than silent.
+    ``added_names`` are the overlay accounts actually attached (in the pack's
+    language); ``skipped`` are overlay accounts whose anchor was unmapped or
+    whose name collided — surfaced so a mis-wired profile/pack pairing is visible
+    rather than silent.
     """
     tree = copy.deepcopy(pack.base_chart)
     defaults = dict(pack.defaults)
@@ -79,17 +94,26 @@ def _merge(pack: LocalizationPack, profile: Optional[SectorProfile]):
     skipped: list[dict] = []
 
     if profile is not None:
+        # Map each profile account's neutral English name -> the localized name
+        # actually created, so profile.defaults (which reference the English
+        # name) resolve to the localized account on this pack.
+        name_map: dict[str, str] = {}
         for acct in profile.accounts:
             parent_name = pack.anchor_account(acct["anchor"])
             if parent_name is None:
                 skipped.append({**acct, "reason": "anchor not mapped in pack"})
                 continue
-            if _attach(tree, parent_name, acct):
-                added.append(acct["name"])
+            display = _localize_name(acct, pack.language)
+            localized = {**acct, "name": display}
+            if _attach(tree, parent_name, localized):
+                added.append(display)
+                name_map[acct["name"]] = display
             else:
                 skipped.append({**acct, "reason": "parent missing or name collision"})
-        # Sector default overrides layer on top of the pack's base defaults.
-        defaults.update(profile.defaults)
+        # Sector default overrides layer on top of the pack's base defaults,
+        # remapped to the localized account names created above.
+        for field, val in profile.defaults.items():
+            defaults[field] = name_map.get(val, val)
 
     return tree, defaults, added, skipped
 
@@ -118,6 +142,56 @@ def _resolved_defaults(company_name: str, defaults: dict) -> dict:
     return {field: f"{leaf} - {abbr}" for field, leaf in defaults.items()}
 
 
+# A company counts as "already configured" if any of its core posting defaults
+# is set — the signal that it has a real, working chart rather than a couple of
+# stray accounts from an abandoned attempt.
+_CORE_DEFAULTS = ("default_income_account", "default_receivable_account",
+                  "default_payable_account")
+
+
+def _existing_state(company_name: str, requested_currency: str) -> dict:
+    """Describe any pre-existing company so setup can warn instead of dead-end.
+
+    Setup is idempotent (it only ever adds missing accounts and fills empty
+    defaults), so an existing company is never a hard error. But two situations
+    warrant an explicit "are you sure": a company already **configured** with its
+    own chart, and a **currency mismatch** (adding a second chart in a different
+    currency mixes two charts). Those set ``needs_confirmation`` — the caller must
+    only proceed when the user insists.
+    """
+    db = get_db()
+    if not db.exists("Company", company_name):
+        return {"company_exists": False, "account_count": 0, "configured": False,
+                "existing_currency": None, "currency_mismatch": False,
+                "needs_confirmation": False, "advisory": ""}
+
+    count = len(db.get_all("Account", filters={"company": company_name}, fields=["name"]))
+    configured = any(db.get_value("Company", company_name, f) for f in _CORE_DEFAULTS)
+    existing_ccy = db.get_value("Company", company_name, "default_currency") or None
+    mismatch = bool(existing_ccy and requested_currency and existing_ccy != requested_currency)
+
+    if mismatch:
+        advisory = (
+            f"'{company_name}' already exists in {existing_ccy}, but this setup is in "
+            f"{requested_currency}. Adding a chart in a different currency mixes two "
+            "charts of accounts — warn the user clearly and proceed only if they insist.")
+    elif configured:
+        advisory = (
+            f"'{company_name}' is already configured ({count} accounts, defaults set). "
+            "Setup will only add accounts that are missing and change nothing else — "
+            "confirm the user wants to add to an already-configured company.")
+    elif count:
+        advisory = (
+            f"'{company_name}' already exists with {count} account(s) but isn't fully "
+            "configured. Setup will fill in the rest and leave the existing accounts alone.")
+    else:
+        advisory = ""
+
+    return {"company_exists": True, "account_count": count, "configured": configured,
+            "existing_currency": existing_ccy, "currency_mismatch": mismatch,
+            "needs_confirmation": bool(mismatch or configured), "advisory": advisory}
+
+
 # ---------------------------------------------------------------------------
 # Public API
 # ---------------------------------------------------------------------------
@@ -157,6 +231,7 @@ def plan_company_setup(company_name: str,
         "accounts": _tree_outline(tree),
         "sector_added_accounts": added,
         "defaults": _resolved_defaults(company_name, defaults),
+        "existing": _existing_state(company_name, ccy),
         "warnings": skipped,
     }
     if profile is not None:
@@ -175,25 +250,33 @@ def apply_company_setup(company_name: str,
                         variant: Optional[str] = None,
                         sector: Optional[str] = None,
                         currency: Optional[str] = None,
-                        force: bool = False) -> dict:
-    """Create the company's chart of accounts, defaults, tax, and cost center.
-
-    Idempotency guard: refuses if the company already has accounts unless
-    ``force=True``. Creates the Company row if it does not exist yet (so the chat
-    can drive setup end-to-end); an already-created company is left in place.
-    Runs in a single transaction.
+                        confirm_existing: bool = False) -> dict:
+    """Converge a company toward the desired chart of accounts (idempotent).
+
+    Runs *alongside* an existing deployment: it creates the company if missing,
+    creates only the accounts that don't already exist, fills only the company
+    defaults that are still empty (never clobbering a configured company), and
+    creates the tax templates / cost center only if absent. Existing data is
+    never modified or deleted, so this is safe to re-run.
+
+    Guardrail (see :func:`_existing_state`): if the company is already configured
+    or the currency mismatches, it returns ``needs_confirmation`` instead of
+    proceeding — the caller must pass ``confirm_existing=True`` (only after the
+    user insists). Runs in a single transaction; returns a reconciliation report.
     """
     db = get_db()
     pack = resolve_pack(country, variant)
     profile = get_profile(sector)
     ccy = currency or pack.currency
 
-    existing = db.get_all("Account", filters={"company": company_name}, fields=["name"])
-    if existing and not force:
+    state = _existing_state(company_name, ccy)
+    if state["needs_confirmation"] and not confirm_existing:
         return {
             "ok": False,
-            "error": f"{company_name} already has {len(existing)} accounts. "
-                     "Pass force=True to rebuild (this does not delete the old ones).",
+            "needs_confirmation": True,
+            "existing": state,
+            "advisory": state["advisory"],
+            "hint": "Warn the user, then re-call with confirm_existing=True only if they insist.",
         }
 
     if not db.exists("Company", company_name):
@@ -206,34 +289,29 @@ def apply_company_setup(company_name: str,
 
     tree, defaults, added, skipped = _merge(pack, profile)
 
-    create_accounts_from_tree(company_name, tree, ccy)
-    apply_company_defaults(company_name, defaults)
+    acct = create_accounts_from_tree(company_name, tree, ccy)          # {created, skipped}
+    dflt = apply_company_defaults(company_name, defaults)              # {set, left, missing}
 
     tax_summary = []
     if pack.setup_tax is not None:
         tax_summary = pack.setup_tax(company_name, ccy) or []
 
-    cost_center = setup_cost_center(company_name)  # commits internally
+    cost_center = setup_cost_center(company_name)  # idempotent, commits internally
     db.commit()
 
-    def _count(nodes):
-        n = 0
-        for _name, d in nodes.items():
-            children = d.get("children")
-            if children:
-                n += _count(children)
-            else:
-                n += 1
-        return n
-
     return {
         "ok": True,
         "company": company_name,
         "currency": ccy,
         "jurisdiction": pack.key,
         "sector": profile.key if profile else None,
-        "accounts_created": _count(tree),
+        "added_to_existing": state["company_exists"],
+        "accounts_created": len(acct["created"]),
+        "accounts_skipped": len(acct["skipped"]),   # already present, left alone
         "sector_added_accounts": added,
+        "defaults_set": dflt["set"],
+        "defaults_left_untouched": dflt["left"],     # already configured, kept
+        "defaults_unresolved": dflt["missing"],
         "cost_center": cost_center,
         "tax_summary": tax_summary,
         "warnings": skipped,

{lambda_erp-0.2.0 → lambda_erp-0.2.2}/lambda_erp/accounting/setup/pack.py

@@ -58,6 +58,10 @@ class LocalizationPack:
     defaults: dict
     variant: Optional[str] = None
     currency: str = "USD"
+    # Primary language of the chart's account names (ISO 639-1). Sector-profile
+    # overlay accounts are rendered in this language so they match the base
+    # chart — "en" for the generic pack, "de" for the Swiss KMU pack, etc.
+    language: str = "en"
     setup_tax: Optional[Callable[[str, str], list]] = None
     notes: str = ""
 

{lambda_erp-0.2.0 → lambda_erp-0.2.2}/lambda_erp/accounting/setup/packs/ch.py

@@ -217,6 +217,8 @@ def ch_setup_tax(company_name, currency):
 
     def _template(title, tax_type, rate, account_leaf):
         name = f"{title} - {abbr}"
+        if db.exists("Tax Template", name):
+            return                      # idempotent: leave an existing template
         db.insert("Tax Template", _dict(
             name=name, title=title, company=company_name, tax_type=tax_type,
         ))
@@ -244,6 +246,7 @@ CH_PACK = register_pack(LocalizationPack(
     variant=None,
     label="Switzerland (Kontenrahmen KMU)",
     currency="CHF",
+    language="de",
     base_chart=CH_CHART,
     anchors=CH_ANCHORS,
     defaults=CH_DEFAULTS,

{lambda_erp-0.2.0 → lambda_erp-0.2.2}/lambda_erp/accounting/setup/profiles.py

@@ -64,8 +64,12 @@ class SectorProfile:
                 )
 
 
-def _acct(anchor, name, account_type=""):
-    return {"anchor": anchor, "name": name, "account_type": account_type}
+def _acct(anchor, name, account_type="", **i18n):
+    """One overlay account. ``name`` is the jurisdiction-neutral English name;
+    ``i18n`` holds localized names keyed by ISO 639-1 (e.g. ``de=..., fr=...``)
+    used when the active pack's language matches, so overlay accounts read in the
+    same language as the base chart."""
+    return {"anchor": anchor, "name": name, "account_type": account_type, "i18n": i18n}
 
 
 # ---------------------------------------------------------------------------
@@ -86,13 +90,21 @@ SERVICES = SectorProfile(
         "tracked separately so they can be re-billed at cost."
     ),
     accounts=[
-        _acct(spine.CURRENT_ASSETS, "Unbilled Revenue / WIP", ""),
-        _acct(spine.CURRENT_LIABILITIES, "Deferred Revenue", ""),
-        _acct(spine.INCOME, "Consulting Revenue", "Income Account"),
-        _acct(spine.OPERATING_EXPENSES, "Subcontractor Costs", ""),
-        _acct(spine.OPERATING_EXPENSES, "Reimbursable Client Expenses", ""),
+        _acct(spine.CURRENT_ASSETS, "Unbilled Revenue / WIP", "",
+              de="Nicht fakturierte Leistungen / Angefangene Arbeiten",
+              fr="Travaux en cours non facturés"),
+        _acct(spine.CURRENT_LIABILITIES, "Deferred Revenue", "",
+              de="Erhaltene Anzahlungen (passive Abgrenzung)",
+              fr="Produits différés"),
+        _acct(spine.INCOME, "Consulting Revenue", "Income Account",
+              de="Beratungserlöse", fr="Produits de conseil"),
+        _acct(spine.OPERATING_EXPENSES, "Subcontractor Costs", "",
+              de="Aufwand für Fremdleistungen", fr="Charges de sous-traitance"),
+        _acct(spine.OPERATING_EXPENSES, "Reimbursable Client Expenses", "",
+              de="Weiterverrechenbare Kundenauslagen",
+              fr="Débours refacturables aux clients"),
     ],
-    defaults={"default_income_account": "Service Revenue"},
+    defaults={"default_income_account": "Consulting Revenue"},
     big_decisions=[
         "Recognise revenue over time (unbilled WIP + deferred revenue) rather "
         "than only at invoice? Recommended for retainers and long engagements.",
@@ -113,11 +125,16 @@ RETAIL_POS = SectorProfile(
         "miscounts) is a normal recurring expense reconciled at stock-take."
     ),
     accounts=[
-        _acct(spine.CURRENT_ASSETS, "Cash Register / Till", "Cash"),
-        _acct(spine.CURRENT_ASSETS, "Merchant Card Clearing", ""),
-        _acct(spine.CURRENT_LIABILITIES, "Sales Tax Payable", "Tax"),
-        _acct(spine.INCOME, "Retail Sales", "Income Account"),
-        _acct(spine.OPERATING_EXPENSES, "Inventory Shrinkage", "Stock Adjustment"),
+        _acct(spine.CURRENT_ASSETS, "Cash Register / Till", "Cash",
+              de="Ladenkasse", fr="Caisse (point de vente)"),
+        _acct(spine.CURRENT_ASSETS, "Merchant Card Clearing", "",
+              de="Kartenzahlungen (Durchlaufkonto)", fr="Compte d'attente cartes"),
+        _acct(spine.CURRENT_LIABILITIES, "Sales Tax Payable", "Tax",
+              de="Geschuldete Umsatzsteuer (MWST)", fr="TVA due sur les ventes"),
+        _acct(spine.INCOME, "Retail Sales", "Income Account",
+              de="Detailhandelserlöse", fr="Produits de la vente au détail"),
+        _acct(spine.OPERATING_EXPENSES, "Inventory Shrinkage", "Stock Adjustment",
+              de="Inventurdifferenzen (Schwund)", fr="Démarque inconnue"),
     ],
     defaults={"default_income_account": "Retail Sales"},
     big_decisions=[
@@ -139,12 +156,18 @@ HOSPITALITY = SectorProfile(
         "and spoilage are expected and tracked."
     ),
     accounts=[
-        _acct(spine.INCOME, "Food Sales", "Income Account"),
-        _acct(spine.INCOME, "Beverage Sales", "Income Account"),
-        _acct(spine.DIRECT_COSTS, "Food Cost", "Cost of Goods Sold"),
-        _acct(spine.DIRECT_COSTS, "Beverage Cost", "Cost of Goods Sold"),
-        _acct(spine.CURRENT_LIABILITIES, "Tips Payable", ""),
-        _acct(spine.OPERATING_EXPENSES, "Spoilage & Waste", "Stock Adjustment"),
+        _acct(spine.INCOME, "Food Sales", "Income Account",
+              de="Küchenumsatz (Speisen)", fr="Ventes de nourriture"),
+        _acct(spine.INCOME, "Beverage Sales", "Income Account",
+              de="Getränkeumsatz", fr="Ventes de boissons"),
+        _acct(spine.DIRECT_COSTS, "Food Cost", "Cost of Goods Sold",
+              de="Warenaufwand Küche (Speisen)", fr="Coût des denrées"),
+        _acct(spine.DIRECT_COSTS, "Beverage Cost", "Cost of Goods Sold",
+              de="Warenaufwand Getränke", fr="Coût des boissons"),
+        _acct(spine.CURRENT_LIABILITIES, "Tips Payable", "",
+              de="Trinkgelder (durchlaufend)", fr="Pourboires à reverser"),
+        _acct(spine.OPERATING_EXPENSES, "Spoilage & Waste", "Stock Adjustment",
+              de="Verderb und Abfall", fr="Pertes et gaspillage"),
     ],
     defaults={"default_income_account": "Food Sales"},
     big_decisions=[
@@ -166,11 +189,16 @@ DISTRIBUTION = SectorProfile(
         "liability and reduce net revenue rather than being an expense."
     ),
     accounts=[
-        _acct(spine.CURRENT_ASSETS, "Inventory - Finished Goods", "Stock"),
-        _acct(spine.CURRENT_ASSETS, "Goods in Transit", "Stock"),
-        _acct(spine.INCOME, "Wholesale Revenue", "Income Account"),
-        _acct(spine.OPERATING_EXPENSES, "Freight Out / Delivery", ""),
-        _acct(spine.CURRENT_LIABILITIES, "Customer Rebates Payable", ""),
+        _acct(spine.CURRENT_ASSETS, "Inventory - Finished Goods", "Stock",
+              de="Vorräte Fertigwaren", fr="Stock de produits finis"),
+        _acct(spine.CURRENT_ASSETS, "Goods in Transit", "Stock",
+              de="Waren unterwegs", fr="Marchandises en transit"),
+        _acct(spine.INCOME, "Wholesale Revenue", "Income Account",
+              de="Grosshandelserlöse", fr="Produits de gros"),
+        _acct(spine.OPERATING_EXPENSES, "Freight Out / Delivery", "",
+              de="Ausgangsfrachten / Versandkosten", fr="Frais de livraison"),
+        _acct(spine.CURRENT_LIABILITIES, "Customer Rebates Payable", "",
+              de="Kundenrückvergütungen (Rückstellung)", fr="Ristournes clients à payer"),
     ],
     defaults={"default_income_account": "Wholesale Revenue"},
     big_decisions=[
@@ -195,11 +223,16 @@ IMPORT_EXPORT = SectorProfile(
         "Gain/Loss accounts already cover these)."
     ),
     accounts=[
-        _acct(spine.CURRENT_ASSETS, "Goods in Transit (Imports)", "Stock"),
-        _acct(spine.DIRECT_COSTS, "Customs Duties & Import Taxes", "Chargeable"),
-        _acct(spine.DIRECT_COSTS, "Inbound Freight & Insurance", "Chargeable"),
-        _acct(spine.CURRENT_LIABILITIES, "Import VAT / GST Payable", "Tax"),
-        _acct(spine.INCOME, "Export Sales", "Income Account"),
+        _acct(spine.CURRENT_ASSETS, "Goods in Transit (Imports)", "Stock",
+              de="Importwaren unterwegs", fr="Marchandises importées en transit"),
+        _acct(spine.DIRECT_COSTS, "Customs Duties & Import Taxes", "Chargeable",
+              de="Zölle und Einfuhrabgaben", fr="Droits de douane et taxes à l'importation"),
+        _acct(spine.DIRECT_COSTS, "Inbound Freight & Insurance", "Chargeable",
+              de="Eingangsfrachten und Versicherung", fr="Fret et assurance à l'import"),
+        _acct(spine.CURRENT_LIABILITIES, "Import VAT / GST Payable", "Tax",
+              de="Einfuhrsteuer (MWST) geschuldet", fr="TVA à l'importation due"),
+        _acct(spine.INCOME, "Export Sales", "Income Account",
+              de="Exporterlöse", fr="Produits d'exportation"),
     ],
     defaults={
         "default_income_account": "Export Sales",
@@ -225,11 +258,16 @@ MANUFACTURING = SectorProfile(
         "when the product is sold, not when it is made."
     ),
     accounts=[
-        _acct(spine.CURRENT_ASSETS, "Raw Materials", "Stock"),
-        _acct(spine.CURRENT_ASSETS, "Work in Progress", "Stock"),
-        _acct(spine.CURRENT_ASSETS, "Finished Goods", "Stock"),
-        _acct(spine.DIRECT_COSTS, "Direct Labour", ""),
-        _acct(spine.DIRECT_COSTS, "Manufacturing Overhead Applied", ""),
+        _acct(spine.CURRENT_ASSETS, "Raw Materials", "Stock",
+              de="Rohstoffe", fr="Matières premières"),
+        _acct(spine.CURRENT_ASSETS, "Work in Progress", "Stock",
+              de="Angefangene Arbeiten", fr="Travaux en cours"),
+        _acct(spine.CURRENT_ASSETS, "Finished Goods", "Stock",
+              de="Fertigerzeugnisse", fr="Produits finis"),
+        _acct(spine.DIRECT_COSTS, "Direct Labour", "",
+              de="Fertigungslöhne (Direktlohn)", fr="Main-d'œuvre directe"),
+        _acct(spine.DIRECT_COSTS, "Manufacturing Overhead Applied", "",
+              de="Verrechnete Fertigungsgemeinkosten", fr="Frais généraux de production imputés"),
     ],
     defaults={},
     big_decisions=[
@@ -254,13 +292,20 @@ CONSTRUCTION = SectorProfile(
         "project."
     ),
     accounts=[
-        _acct(spine.CURRENT_ASSETS, "Costs in Excess of Billings", ""),
-        _acct(spine.CURRENT_ASSETS, "Retention Receivable", "Receivable"),
-        _acct(spine.CURRENT_LIABILITIES, "Billings in Excess of Costs", ""),
-        _acct(spine.CURRENT_LIABILITIES, "Retention Payable", ""),
-        _acct(spine.INCOME, "Contract Revenue", "Income Account"),
-        _acct(spine.DIRECT_COSTS, "Job Costs - Materials", ""),
-        _acct(spine.DIRECT_COSTS, "Job Costs - Subcontractors", ""),
+        _acct(spine.CURRENT_ASSETS, "Costs in Excess of Billings", "",
+              de="Nicht fakturierte Projektleistungen", fr="Travaux en cours excédant la facturation"),
+        _acct(spine.CURRENT_ASSETS, "Retention Receivable", "Receivable",
+              de="Rückbehalte (Forderungen)", fr="Retenues de garantie à recevoir"),
+        _acct(spine.CURRENT_LIABILITIES, "Billings in Excess of Costs", "",
+              de="Fakturierte Leistungen über Baufortschritt", fr="Facturation excédant les travaux"),
+        _acct(spine.CURRENT_LIABILITIES, "Retention Payable", "",
+              de="Rückbehalte (Verbindlichkeiten)", fr="Retenues de garantie à payer"),
+        _acct(spine.INCOME, "Contract Revenue", "Income Account",
+              de="Projekterlöse (Werkverträge)", fr="Produits sur contrats"),
+        _acct(spine.DIRECT_COSTS, "Job Costs - Materials", "",
+              de="Projektkosten Material", fr="Coûts de chantier - matériaux"),
+        _acct(spine.DIRECT_COSTS, "Job Costs - Subcontractors", "",
+              de="Projektkosten Fremdleistungen", fr="Coûts de chantier - sous-traitance"),
     ],
     defaults={"default_income_account": "Contract Revenue"},
     big_decisions=[

{lambda_erp-0.2.0 → lambda_erp-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lambda-erp"
-version = "0.2.0"
+version = "0.2.2"
 description = "Core ERP logic - accounting, sales, purchasing, inventory"
 readme = "README.md"
 license = "MIT"