quints 0.4.0__tar.gz → 0.4.1__tar.gz

{quints-0.4.0 → quints-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quints
-Version: 0.4.0
+Version: 0.4.1
 Summary: Swiss VAT & accounting toolkit for plain-text (beancount) books: MWST reports and quarterly settlement, Bezugsteuer helpers, BAZG daily FX rates, QR-bill invoicing, KMU statutory statements, and statement importers (UBS MT940, Wise, Stripe) that draft into a staging area
 License: GPL-2.0-only
 License-File: LICENSE

{quints-0.4.0 → quints-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quints"
-version = "0.4.0"
+version = "0.4.1"
 description = "Swiss VAT & accounting toolkit for plain-text (beancount) books: MWST reports and quarterly settlement, Bezugsteuer helpers, BAZG daily FX rates, QR-bill invoicing, KMU statutory statements, and statement importers (UBS MT940, Wise, Stripe) that draft into a staging area"
 readme = "README.md"
 requires-python = ">=3.10"

{quints-0.4.0 → quints-0.4.1}/src/quints/cli.py

@@ -2,13 +2,18 @@
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import replace
 from datetime import date as Date
 from decimal import Decimal, InvalidOperation
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 import typer
 
+if TYPE_CHECKING:
+    from _typeshed import DataclassInstance
+
 from . import (
     config as config_mod,
 )
@@ -66,7 +71,7 @@ def _print_version(value: bool) -> None:
 
 
 @app.callback()
-def _main(
+def root(
     config: Path | None = typer.Option(
         None, "--config", help="quints.toml path (default: ./quints.toml, else built-in defaults)."
     ),
@@ -103,7 +108,9 @@ def _lang_option() -> str:
     )
 
 
-def _emit(report, render, lang: str | None, as_json: bool) -> None:
+def _emit(
+    report: DataclassInstance, render: Callable[..., object], lang: str | None, as_json: bool
+) -> None:
     lang = lang or config_mod.get().report_language
     if as_json:
         import dataclasses
@@ -126,7 +133,7 @@ def _parse_date(text: str) -> Date:
         raise typer.Exit(1) from None
 
 
-def _json_out(payload) -> None:
+def _json_out(payload: object) -> None:
     """Emit a machine-readable payload (Decimals/dates as strings)."""
     import json
 
@@ -535,11 +542,13 @@ def import_wise(
             raise typer.Exit(1)
         _parse_date(from_)
         _parse_date(to)
+        from beangulp_wise import ScaChallenge, WiseError
+
         try:
             statements = importing_mod.fetch_wise(from_, to, out)
-        except importing_mod.WiseError as e:
+        except WiseError as e:
             typer.secho(f"ERROR: {e}", fg="red", err=True)
-            if isinstance(e, importing_mod.ScaChallenge):
+            if isinstance(e, ScaChallenge):
                 typer.secho(
                     "Statements are SCA-protected: upload .wise/public.pem in Wise "
                     "(Settings → API tokens → Manage public keys) and set "
@@ -608,18 +617,19 @@ def import_stripe(
     _report_import(result, as_json)
 
 
-def _report_import(result, as_json: bool = False) -> None:
+def _report_import(result: importing_mod.ImportResult, as_json: bool = False) -> None:
     if as_json:
+        from beancount.core import data
 
-        def txn(t):
+        def txn(t: data.Transaction) -> dict[str, object]:
             u = t.postings[0].units
             return {
                 "date": str(t.date),
                 "flag": t.flag,
                 "payee": t.payee,
                 "narration": t.narration,
-                "amount": u.number,
-                "currency": u.currency,
+                "amount": u.number if u else None,
+                "currency": u.currency if u else None,
             }
 
         _json_out(
@@ -789,6 +799,8 @@ def invoice(
                 print(ledger_draft)
                 print()
             elif cc.ok:
+                if cc.ledger_total is None:  # unreachable: found implies totals are set
+                    raise ValueError(f"cross-check for {inv.number} lost its ledger total")
                 ui.console.print(
                     f"[ok]Ledger match[/] ({cc.date}): {inv.currency} {m.money(cc.ledger_total)}"
                 )
@@ -797,6 +809,9 @@ def invoice(
                         f"[warn]booking date {cc.date} ≠ invoice date {inv.issue_date}[/]"
                     )
             else:
+                if cc.ledger_total is None or cc.invoice_total is None:
+                    # unreachable: found implies totals are set, but narrows the Optionals
+                    raise ValueError(f"cross-check for {inv.number} lost its totals")
                 ui.console.print(
                     f"[err]Ledger CONFLICT[/] ({cc.date}): {inv.number} is already booked "
                     f"at {m.money(cc.ledger_total)} but the invoice says "
@@ -812,7 +827,7 @@ def invoice(
                 "kind": inv.kind,
                 "currency": inv.currency,
                 "issue_date": inv.issue_date,
-                "customer": inv.customer.name,
+                "customer": inv.resolved_customer.name,
                 "pdf": str(path),
                 "totals": totals.model_dump(),
                 "qr_payload_ok": qr_ok,

{quints-0.4.0 → quints-0.4.1}/src/quints/config.py

@@ -120,67 +120,80 @@ class Config:
     import_stripe: StripeImport | None = None
 
 
-def _rules(section: dict) -> tuple[tuple[str, str, str], ...]:
-    return tuple((r[0], r[1], r[2]) for r in section.get("rules", ()))
-
-
-def _accounts_map(section: dict, default) -> tuple[tuple[str, str], ...]:
-    if "accounts" not in section:
+def _rules(section: dict[str, object]) -> tuple[tuple[str, str, str], ...]:
+    rules = section.get("rules")
+    if not isinstance(rules, list):
+        return ()
+    return tuple((r[0], r[1], r[2]) for r in rules)
+
+
+def _accounts_map(
+    section: dict[str, object], default: tuple[tuple[str, str], ...]
+) -> tuple[tuple[str, str], ...]:
+    accounts = section.get("accounts")
+    if not isinstance(accounts, dict):
         return default
-    return tuple(sorted(section["accounts"].items()))
+    return tuple(sorted(accounts.items()))
 
 
-def _import_sections(raw: dict) -> dict:
-    imports = raw.get("import") or {}
-    updates: dict = {}
-    if "ubs" in imports:
-        s = imports["ubs"]
+def _import_sections(raw: dict[str, object]) -> dict[str, object]:
+    imports = raw.get("import")
+    if not isinstance(imports, dict):
+        return {}
+    updates: dict[str, object] = {}
+    ubs = imports.get("ubs")
+    if isinstance(ubs, dict):
         updates["import_ubs"] = UbsImport(
-            account=s.get("account", UbsImport.account),
-            iban=s.get("iban"),
-            currency=s.get("currency", UbsImport.currency),
-            rules=_rules(s),
+            account=ubs.get("account", UbsImport.account),
+            iban=ubs.get("iban"),
+            currency=ubs.get("currency", UbsImport.currency),
+            rules=_rules(ubs),
         )
-    if "wise" in imports:
-        s = imports["wise"]
+    wise = imports.get("wise")
+    if isinstance(wise, dict):
         updates["import_wise"] = WiseImport(
-            accounts=_accounts_map(s, WiseImport.accounts),
-            fees_account=s.get("fees_account", WiseImport.fees_account),
-            holder=s.get("holder"),
-            rules=_rules(s),
+            accounts=_accounts_map(wise, WiseImport.accounts),
+            fees_account=wise.get("fees_account", WiseImport.fees_account),
+            holder=wise.get("holder"),
+            rules=_rules(wise),
         )
-    if "stripe" in imports:
-        s = imports["stripe"]
+    stripe = imports.get("stripe")
+    if isinstance(stripe, dict):
         updates["import_stripe"] = StripeImport(
-            accounts=_accounts_map(s, StripeImport.accounts),
-            fees_account=s.get("fees_account", StripeImport.fees_account),
-            tax_account=s.get("tax_account", StripeImport.tax_account),
-            account_id=s.get("account_id"),
-            rules=_rules(s),
+            accounts=_accounts_map(stripe, StripeImport.accounts),
+            fees_account=stripe.get("fees_account", StripeImport.fees_account),
+            tax_account=stripe.get("tax_account", StripeImport.tax_account),
+            account_id=stripe.get("account_id"),
+            rules=_rules(stripe),
         )
     return updates
 
 
-def _from_mapping(raw: dict) -> Config:
-    entity = raw.get("entity") or {}
-    ledger_ = raw.get("ledger") or {}
-    accounts = raw.get("accounts") or {}
-    report = raw.get("report") or {}
+def _from_mapping(raw: dict[str, object]) -> Config:
+    def section(key: str) -> dict[str, object]:
+        value = raw.get(key)
+        return value if isinstance(value, dict) else {}
+
+    entity = section("entity")
+    ledger_ = section("ledger")
+    accounts = section("accounts")
+    report = section("report")
     cfg = Config()
-    updates: dict = {}
+    updates: dict[str, object] = {}
 
-    def take(section: dict, key: str, field: str, cast=None):
+    def take(section: dict[str, object], key: str, field: str) -> None:
         if key in section:
-            value = section[key]
-            updates[field] = cast(value) if cast else value
+            updates[field] = section[key]
 
     take(entity, "name", "entity_name")
     take(entity, "legal_form", "legal_form")
     take(entity, "vat_method", "vat_method")
     take(entity, "vat_registered_since", "vat_registered_since")
     take(entity, "operating_currency", "operating_currency")
-    take(ledger_, "main", "ledger_main", Path)
-    take(ledger_, "prices", "ledger_prices", Path)
+    if "main" in ledger_:
+        updates["ledger_main"] = Path(str(ledger_["main"]))
+    if "prices" in ledger_:
+        updates["ledger_prices"] = Path(str(ledger_["prices"]))
     for key in (
         "input_vat",
         "output_vat",

{quints-0.4.0 → quints-0.4.1}/src/quints/fava/__init__.py

@@ -12,9 +12,12 @@ Enable in the beancount file:
 from __future__ import annotations
 
 import re
+from collections.abc import Sequence
 from datetime import datetime, timezone
 from pathlib import Path
 
+from beancount.core import data
+from fava.beans import abc as fava_abc
 from fava.ext import FavaExtensionBase
 
 from .. import config, receivables, settlement
@@ -22,6 +25,26 @@ from .. import inbox as inbox_mod
 
 _DRAFT_LINE = re.compile(r"^\d{4}-\d{2}-\d{2} +([*!]) ", re.M)
 
+_BEANCOUNT_DIRECTIVES = (
+    data.Open,
+    data.Close,
+    data.Commodity,
+    data.Pad,
+    data.Balance,
+    data.Transaction,
+    data.Note,
+    data.Event,
+    data.Query,
+    data.Price,
+    data.Document,
+    data.Custom,
+)
+
+
+def _entries(entries: Sequence[fava_abc.Directive]) -> data.Directives:
+    """Re-type fava's ``abc.Directive`` view of the same beancount objects."""
+    return [e for e in entries if isinstance(e, _BEANCOUNT_DIRECTIVES)]
+
 
 class QuintDashboard(FavaExtensionBase):
     """VAT, receivables, and review-queue panel."""
@@ -46,11 +69,13 @@ class QuintDashboard(FavaExtensionBase):
         return settlement.outstanding(
             Path(self.ledger.beancount_file_path),
             cfg=self._cfg,
-            entries=self.ledger.all_entries,
+            entries=_entries(self.ledger.all_entries),
         )
 
     def open_receivables(self):
-        return receivables.compute_from_entries(self.ledger.all_entries, self.today(), self._cfg)
+        return receivables.compute_from_entries(
+            _entries(self.ledger.all_entries), self.today(), self._cfg
+        )
 
     def staging(self):
         """Pending staging drafts: (file name, total drafts, flagged drafts)."""
@@ -62,4 +87,4 @@ class QuintDashboard(FavaExtensionBase):
 
     def inbox(self):
         """Inbox inventory (hints + duplicate/linked status) — see quints.inbox."""
-        return inbox_mod.scan(self._root, self.ledger.all_entries)
+        return inbox_mod.scan(self._root, _entries(self.ledger.all_entries))

{quints-0.4.0 → quints-0.4.1}/src/quints/fx.py

@@ -73,7 +73,7 @@ def compute(ledger_path: Path, at: str, cfg: config.Config | None = None) -> lis
             root = p.account.split(":", 1)[0]
             if cfg.entity_marker not in p.account or root not in ("Assets", "Liabilities"):
                 continue
-            if p.units.currency == "CHF":
+            if p.units is None or p.units.currency == "CHF":
                 continue
             inventories.setdefault(p.account, Inventory()).add_position(p)
             weight = bc_convert.get_weight(p)
@@ -90,11 +90,14 @@ def compute(ledger_path: Path, at: str, cfg: config.Config | None = None) -> lis
     revaluations: list[Revaluation] = []
     for account, inv in sorted(inventories.items()):
         for pos in inv:
-            units = pos.units.number.quantize(Decimal("0.01"))
+            number = pos.units.number
+            if number is None:
+                continue
+            units = number.quantize(Decimal("0.01"))
             if not units:
                 continue
             rate_date, rate = ledger.rate(price_map, pos.units.currency, on)
-            if rate is None:
+            if rate is None or rate_date is None:
                 raise RateUnavailable(pos.units.currency, on)
             market = ledger.rappen(units * Decimal(rate))
             book_value = ledger.rappen(book.get((account, pos.units.currency), Decimal("0")))

{quints-0.4.0 → quints-0.4.1}/src/quints/importing.py

@@ -25,9 +25,12 @@ from __future__ import annotations
 import json
 import os
 import re
+from collections.abc import Sequence
 from dataclasses import dataclass, field
 from datetime import date as TodayDate
+from decimal import Decimal
 from pathlib import Path
+from typing import TypeVar
 
 from beancount.core import data
 from beancount.parser import printer
@@ -45,7 +48,10 @@ LEGACY_WINDOW_DAYS = 3
 DEFAULT_STAGING = Path("staging")
 
 
-def _require(section, name: str, *keys: str):
+_Section = TypeVar("_Section", config.UbsImport, config.WiseImport, config.StripeImport)
+
+
+def _require(section: _Section | None, name: str, *keys: str) -> _Section:
     """The importer's entity data ([import.<name>] in quints.toml) is config."""
     if section is None:
         raise ValueError(f"[import.{name}] is not configured — add it to quints.toml")
@@ -100,38 +106,54 @@ def stripe_importer(cfg: config.Config | None = None) -> StripeImporter:
 class ImportResult:
     source: str
     out_path: Path | None = None
-    drafts: list = field(default_factory=list)  # Transactions written to staging
-    balances: list = field(default_factory=list)  # closing-balance assertions
+    drafts: list[data.Transaction] = field(default_factory=list)  # written to staging
+    balances: list[data.Balance] = field(default_factory=list)  # closing-balance assertions
     skipped_ref: int = 0  # deduped by reference metadata
-    legacy_matches: list = field(default_factory=list)  # (draft, booked date) pairs
-    receivable_matches: list = field(default_factory=list)  # (invoice number, draft)
+    legacy_matches: list[tuple[data.Transaction, TodayDate]] = field(
+        default_factory=list
+    )  # (draft, booked date) pairs
+    receivable_matches: list[tuple[str, data.Transaction]] = field(
+        default_factory=list
+    )  # (invoice number, draft)
 
 
-def _cash_pool(entries, accounts: set[str]) -> list[tuple]:
+def _cash_pool(
+    entries: Sequence[data.Directive], accounts: set[str]
+) -> list[tuple[TodayDate, Decimal, str]]:
     """Mutable pool of (date, amount, account) cash postings for legacy matching."""
-    pool = []
+    pool: list[tuple[TodayDate, Decimal, str]] = []
     for e in entries:
         if not isinstance(e, data.Transaction):
             continue
         for p in e.postings:
-            if p.account in accounts:
+            if p.account in accounts and p.units is not None and p.units.number is not None:
                 pool.append((e.date, p.units.number, p.account))
     return pool
 
 
-def _split(result: ImportResult, extracted, pool) -> None:
+def _split(
+    result: ImportResult,
+    extracted: Sequence[data.Directive],
+    pool: list[tuple[TodayDate, Decimal, str]],
+) -> None:
     """Sort extracted entries into drafts / legacy matches / balance assertions."""
     for entry in extracted:
         if isinstance(entry, data.Balance):
             result.balances.append(entry)
             continue
+        if not isinstance(entry, data.Transaction):
+            continue
         cash = entry.postings[0]
+        if cash.units is None or cash.units.number is None:
+            result.drafts.append(entry)  # no amount to match on — review by hand
+            continue
+        cash_number = cash.units.number
         match = next(
             (
                 (d, n, a)
                 for d, n, a in pool
                 if a == cash.account
-                and n == cash.units.number
+                and n == cash_number
                 and abs((d - entry.date).days) <= LEGACY_WINDOW_DAYS
             ),
             None,
@@ -143,7 +165,9 @@ def _split(result: ImportResult, extracted, pool) -> None:
             result.drafts.append(entry)
 
 
-def _match_receivables(result: ImportResult, existing, cfg: config.Config) -> None:
+def match_receivables(
+    result: ImportResult, existing: Sequence[data.Directive], cfg: config.Config
+) -> None:
     """Link incoming drafts to open invoices (docs/plans/02 §2.1).
 
     `quints invoice` derives the QRR (QR-bill) and SCOR/RF (SEPA) references
@@ -160,7 +184,7 @@ def _match_receivables(result: ImportResult, existing, cfg: config.Config) -> No
 
     for i, draft in enumerate(result.drafts):
         cash = draft.postings[0]
-        if cash.units is None or cash.units.number <= 0:
+        if cash.units is None or cash.units.number is None or cash.units.number <= 0:
             continue  # only incoming payments clear receivables
         blob = " ".join(
             [draft.payee or "", draft.narration or ""]
@@ -208,8 +232,9 @@ def run_ubs(
 ) -> ImportResult:
     cfg = cfg or config.get()
     importer = ubs_importer(cfg)
+    ubs = _require(cfg.import_ubs, "ubs", "iban")
     if not importer.identify(str(statement)):
-        raise ValueError(f"{statement} is not an MT940 statement for {cfg.import_ubs.iban}")
+        raise ValueError(f"{statement} is not an MT940 statement for {ubs.iban}")
 
     existing, _ = ledger.load_entries(ledger_path)
     total = len(importer.extract(str(statement), existing=[]))
@@ -217,8 +242,8 @@ def run_ubs(
 
     result = ImportResult(source=str(statement))
     result.skipped_ref = total - len(extracted)
-    _split(result, extracted, _cash_pool(existing, {cfg.import_ubs.account}))
-    _match_receivables(result, existing, cfg)
+    _split(result, extracted, _cash_pool(existing, {ubs.account}))
+    match_receivables(result, existing, cfg)
     _write_staging(result, out_dir, "ubs")
     return result
 
@@ -231,7 +256,7 @@ def run_wise(
 ) -> ImportResult:
     cfg = cfg or config.get()
     importer = wise_importer(cfg)
-    wise = cfg.import_wise
+    wise = _require(cfg.import_wise, "wise")
     for statement in statements:
         if not importer.identify(str(statement)):
             raise ValueError(
@@ -240,8 +265,8 @@ def run_wise(
             )
 
     existing, _ = ledger.load_entries(ledger_path)
-    raw: list = []  # without ledger dedup, to count reference skips
-    deduped: list = []
+    raw: data.Directives = []  # without ledger dedup, to count reference skips
+    deduped: data.Directives = []
     for statement in statements:
         raw += importer.extract(str(statement), existing=[])
         deduped += importer.extract(str(statement), existing=existing)
@@ -249,7 +274,7 @@ def run_wise(
     result = ImportResult(source=", ".join(str(s) for s in statements))
     result.skipped_ref = _txn_count(raw) - _txn_count(deduped)
     _split(result, merge_conversions(deduped), _cash_pool(existing, set(wise.account_map.values())))
-    _match_receivables(result, existing, cfg)
+    match_receivables(result, existing, cfg)
     _write_staging(result, out_dir, "wise")
     return result
 
@@ -262,7 +287,7 @@ def run_stripe(
 ) -> ImportResult:
     cfg = cfg or config.get()
     importer = stripe_importer(cfg)
-    stripe = cfg.import_stripe
+    stripe = _require(cfg.import_stripe, "stripe", "account_id")
     for statement in statements:
         if not importer.identify(str(statement)):
             raise ValueError(
@@ -271,8 +296,8 @@ def run_stripe(
             )
 
     existing, _ = ledger.load_entries(ledger_path)
-    raw: list = []  # without ledger dedup, to count reference skips
-    deduped: list = []
+    raw: data.Directives = []  # without ledger dedup, to count reference skips
+    deduped: data.Directives = []
     for statement in statements:
         raw += importer.extract(str(statement), existing=[])
         deduped += importer.extract(str(statement), existing=existing)
@@ -280,12 +305,12 @@ def run_stripe(
     result = ImportResult(source=", ".join(str(s) for s in statements))
     result.skipped_ref = _txn_count(raw) - _txn_count(deduped)
     _split(result, deduped, _cash_pool(existing, set(stripe.account_map.values())))
-    _match_receivables(result, existing, cfg)
+    match_receivables(result, existing, cfg)
     _write_staging(result, out_dir, "stripe")
     return result
 
 
-def _txn_count(entries) -> int:
+def _txn_count(entries: Sequence[data.Directive]) -> int:
     return sum(1 for e in entries if isinstance(e, data.Transaction))
 
 
@@ -297,6 +322,9 @@ def fetch_wise(
 ) -> list[Path]:
     """Download one statement.json per currency balance into ``out_dir``."""
     wise = _require((cfg or config.get()).import_wise, "wise", "holder")
+    holder = wise.holder
+    if not holder:  # unreachable: _require checked, but narrows the Optional
+        raise ValueError("[import.wise] needs 'holder' in quints.toml")
     _load_env()
     token = os.environ.get("QUINTS_WISE_API_TOKEN")
     if not token:
@@ -307,16 +335,19 @@ def fetch_wise(
         pem = Path(key_path).read_bytes()
 
     client = WiseClient(token, private_key_pem=pem)
-    profile = client.profile_id(wise.holder)
+    profile = client.profile_id(holder)
     paths: list[Path] = []
     out_dir.mkdir(exist_ok=True)
     for balance in client.balances(profile):
         currency = balance["currency"]
-        if currency not in wise.account_map:
+        if not isinstance(currency, str) or currency not in wise.account_map:
             continue
+        balance_id = balance["id"]
+        if not isinstance(balance_id, int):
+            raise ValueError(f"Wise balance for {currency} has a non-integer id: {balance_id!r}")
         statement = client.balance_statement(
             profile,
-            balance["id"],
+            balance_id,
             currency,
             f"{interval_start}T00:00:00.000Z",
             f"{interval_end}T23:59:59.999Z",
@@ -362,7 +393,7 @@ def fetch_stripe(
             moment += dt.timedelta(days=1)
         return int(moment.timestamp()) - (1 if end else 0)
 
-    wrapper: dict = {
+    wrapper: dict[str, object] = {
         "account": {"id": account.get("id")},
         "data": client.balance_transactions(_ts(interval_start, False), _ts(interval_end, True)),
     }

{quints-0.4.0 → quints-0.4.1}/src/quints/inbox.py

@@ -41,7 +41,7 @@ def _sha(path: Path) -> str:
     return hashlib.sha256(path.read_bytes()).hexdigest()[:12]
 
 
-def _linked_basenames(entries) -> set[str]:
+def _linked_basenames(entries: data.Directives) -> set[str]:
     names: set[str] = set()
     for e in entries:
         if not isinstance(e, data.Transaction) or not e.meta:
@@ -52,7 +52,7 @@ def _linked_basenames(entries) -> set[str]:
     return names
 
 
-def scan(root: Path, entries) -> list[InboxDoc]:
+def scan(root: Path, entries: data.Directives) -> list[InboxDoc]:
     box_dir = root / "inbox"
     if not box_dir.is_dir():
         return []
@@ -75,7 +75,7 @@ def scan(root: Path, entries) -> list[InboxDoc]:
                 filed_by_hash.setdefault(_sha(p), p)
 
     linked = _linked_basenames(entries)
-    out = []
+    out: list[InboxDoc] = []
     for p in files:
         m = _NAMED.match(p.name)
         dup = filed_by_hash.get(_sha(p))

{quints-0.4.0 → quints-0.4.1}/src/quints/invoice/draft.py

@@ -16,10 +16,11 @@ def _slug(text: str) -> str:
 def build_draft(inv: Invoice, totals: Totals, cfg: config.Config | None = None) -> str:
     """A balanced receivable booking matching what `verify.cross_check` expects."""
     cfg = cfg or config.get()
+    customer = inv.resolved_customer
     ccy = inv.currency
     income = cfg.income_export if inv.kind == "export" else cfg.income_domestic
     narration = f"{inv.supply} invoiced".strip() if inv.supply else f"Invoice {inv.number}"
-    doc = f"{inv.issue_date}.{_slug(inv.customer.name)}.{_slug(inv.supply or inv.number)}.pdf"
+    doc = f"{inv.issue_date}.{_slug(customer.name)}.{_slug(inv.supply or inv.number)}.pdf"
 
     legs: list[tuple[str, str]] = [(cfg.receivable, f"{totals.grand_total:>10.2f} {ccy}")]
     legs.append((income, f"{-totals.subtotal:>10.2f} {ccy}"))
@@ -30,7 +31,7 @@ def build_draft(inv: Invoice, totals: Totals, cfg: config.Config | None = None)
 
     width = max(len(a) for a, _ in legs) + 4
     lines = [
-        f'{inv.issue_date} * "{inv.customer.name}" "{narration}" ^{inv.number}',
+        f'{inv.issue_date} * "{customer.name}" "{narration}" ^{inv.number}',
         f'    invoice: "{inv.number}"',
         f'    document: "{doc}"  ; TODO file the PDF under documents/{income.replace(":", "/")}/',
     ]

{quints-0.4.0 → quints-0.4.1}/src/quints/invoice/labels.py

@@ -78,7 +78,7 @@ LABELS = {
 }
 
 
-def labels(language: str) -> dict:
+def labels(language: str) -> dict[str, str]:
     """Label set for `language` (a locale's language subtag). `Invoice.locale`
     is validated at load, so the fallback only guards programmatic callers."""
     return LABELS.get(language, LABELS["de"])