quints 0.3.0__tar.gz → 0.4.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quints
-Version: 0.3.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
@@ -27,6 +27,8 @@ Description-Content-Type: text/markdown
 
 Swiss VAT & accounting toolkit for plain-text ([beancount](https://github.com/beancount/beancount)) books.
 
+![quints init scaffolds sample books, quints check validates them, and quints mwst prints the Form-310 VAT return](https://raw.githubusercontent.com/sealambda/quints/main/docs/assets/quickstart.gif)
+
 Everything a Swiss micro-company (GmbH, AG, or Einzelfirma) needs on top of beancount + Fava:
 
 - **MWST**: quarterly VAT report mapped to the ESTV form Ziffern, settlement

{quints-0.3.0 → quints-0.4.1}/README.md

@@ -2,6 +2,8 @@
 
 Swiss VAT & accounting toolkit for plain-text ([beancount](https://github.com/beancount/beancount)) books.
 
+![quints init scaffolds sample books, quints check validates them, and quints mwst prints the Form-310 VAT return](https://raw.githubusercontent.com/sealambda/quints/main/docs/assets/quickstart.gif)
+
 Everything a Swiss micro-company (GmbH, AG, or Einzelfirma) needs on top of beancount + Fava:
 
 - **MWST**: quarterly VAT report mapped to the ESTV form Ziffern, settlement

quints-0.4.1/examples/.gitignore

@@ -0,0 +1,8 @@
+# quints working directories. documents/ (filed sources and rendered
+# invoices) is deliberately NOT ignored — the ledger links to it.
+/staging/
+.env
+__pycache__/
+.venv/
+.DS_Store
+.wise/

quints-0.4.1/examples/AGENTS.md

@@ -0,0 +1,120 @@
+# Working on Example GmbH's books with an AI agent
+
+These are plain-text ([beancount](https://beancount.github.io)) books managed
+with [`quints`](https://github.com/sealambda/quints). **`quints` is a
+deterministic tool — you drive it, it never calls a model.** Your job is to
+extend and maintain the ledger; `quints` validates and reports on it.
+
+## Setup
+
+`uv sync` once — it installs quints, which brings beancount and fava along.
+Then `uv run quints check` (or activate the venv and call `quints` and the
+standard beancount tools directly).
+
+This project is a git repository; `quints init` committed the pristine
+scaffold. Work in reviewable steps: `git diff` before moving drafts into
+`books/`, commit once `quints check` passes — the history is the audit trail.
+
+## Layout
+
+- `main.bean` — options, plugins, includes; the entry point every tool loads.
+  `plugin "quints.plugins.kmu"` is enabled: every `*:CH:GmbH:*` account
+  **must** be opened with a four-digit `kmu:` code (Swiss KMU Kontenrahmen).
+- `accounts.bean` — the chart of accounts (all `open` directives).
+- `books/2026.bean` — transactions, one file per fiscal year. `main.bean`
+  includes `books/*.bean`, so a new year just needs a new file.
+- `commodities.bean` — currencies; `prices.bean` — FX rates, refresh with
+  `quints prices sync`.
+- `quints.toml` — entity config (name, legal form, VAT, importer rules). VAT
+  *rates* are law and live in code, not here.
+- `staging/` — importer drafts land here (git-ignored, transient).
+- `inbox/` — incoming source documents, not yet filed.
+- `documents/` — filed documents, mirroring the account tree as
+  `documents/<Account/Tree>/YYYY-MM-DD.payee.description.pdf`. Committed:
+  the ledger links to these files (`fava.plugins.link_documents`).
+- `invoicing/` — issuer identity (`issuer.yaml`), customer registry
+  (`customers.yaml`), one YAML per issued invoice.
+
+## Extending the chart of accounts (the part that needs judgement)
+
+Add income/expense sub-trees for this business as `open` directives in
+`accounts.bean`, each with the KMU code it rolls up to, e.g.:
+
+```beancount
+2026-01-01 open Expenses:CH:GmbH:Marketing:Ads CHF
+  kmu: "6600"  ; Advertising
+```
+
+See the codes already in use:
+
+```bash
+quints report konten --year 2026
+```
+
+Pick codes from the KMU Kontenrahmen; `quints check` fails on a `:CH:GmbH:`
+account with no valid `kmu:` code.
+
+## The loop — money out (statements → books)
+
+1. Draft bank/PSP activity into `staging/`. Configured importers:
+   - `quints import ubs <statement.mt940>` — the MT940 export from UBS e-banking; no credentials.
+   - `quints import wise --fetch --from <date> --to <date>` — needs `QUINTS_WISE_API_TOKEN` in `.env` (plus `QUINTS_WISE_PRIVATE_KEY` for SCA-protected profiles; the key pair lives in `.wise/`, git-ignored).
+   - `quints import stripe --fetch --from <date> --to <date>` — needs `QUINTS_STRIPE_API_KEY` in `.env` (a restricted read-only key for the `[import.stripe]` account).
+2. Review each draft in `staging/`. A draft is a flagged (`!`) transaction
+   with only the cash leg known:
+
+```beancount
+2026-07-20 ! "ACME AG" "Payment order"
+  Assets:CH:GmbH:Current:UBS:CHF  -250.00 CHF
+```
+
+   Complete the counter leg, decide the VAT treatment (InputVAT /
+   Bezugsteuer / none), link the source document, flip `!` to `*`, and move
+   it into `books/2026.bean`. `quints match` scores staging drafts and
+   inbox documents against invoices and bookings.
+3. **Always** `quints check` before you consider the books consistent.
+
+## The loop — money in (invoice → receivable → payment)
+
+1. Describe the invoice as a YAML file in `invoicing/` (each file carries a
+   `$schema` modeline, so schema-aware editors validate it as you type).
+2. `quints invoice invoicing/<file>.yaml` renders the PDF into `documents/`
+   under the income account and cross-checks the total against the ledger.
+   Not booked yet? It prints the receivable draft to paste into
+   `books/2026.bean`.
+3. The payment arrives with the next bank import; the draft is matched to
+   the open invoice by its QR/SCOR reference. `quints receivables` shows
+   what is still open.
+
+## Machine-readable surfaces (prefer these over scraping text)
+
+Every reporting command takes `--json` — stable keys, ISO dates, decimal
+strings:
+
+```bash
+quints check --json
+quints mwst -q 2026-Q3 --json
+quints status --json
+quints report bilanz --at 2026-12-31 --json
+quints receivables --json
+```
+
+JSON Schemas for the invoicing files are hosted at
+https://sealambda.github.io/quints/schema/ (`quints schema` writes them
+locally to `invoicing/schema/`).
+
+Never invent VAT numbers or rates — compute them with `quints mwst`.
+
+## Sample data — replace before the books are real
+
+The scaffold seeded a demo quarter so every command has data. Before
+booking real activity:
+
+- [ ] `invoicing/issuer.yaml` — the VAT ID (CHE-267.359.056 MWST) and both
+      IBANs are checksum-valid fakes; put the real ones in.
+- [ ] `invoicing/customers.yaml` — replace the demo customers (acme, globex).
+- [ ] `invoicing/acme-2026-07.yaml` and `invoicing/globex-2026-08.yaml`
+      — delete the demo invoices.
+- [ ] `books/2026.bean` — delete the block marked *sample activity*.
+- [ ] `prices.bean` — drop the demo EUR rates, then `quints prices sync`.
+- [ ] `quints.toml` — the placeholder IBAN under `[import.ubs]`.

quints-0.4.1/examples/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

{quints-0.3.0 → quints-0.4.1}/examples/invoicing/acme-2026-07.yaml

@@ -1,3 +1,4 @@
+# yaml-language-server: $schema=https://sealambda.github.io/quints/schema/invoice.schema.json
 # Sample domestic invoice — a Swiss QR-bill. It ties to the ^INV2026014
 # booking in books/2026.bean (net 1'000.00 + 8.1% VAT = 1'081.00), so
 # `quints invoice` cross-checks it clean against the ledger.

{quints-0.3.0 → quints-0.4.1}/examples/invoicing/customers.yaml

@@ -1,3 +1,4 @@
+# yaml-language-server: $schema=https://sealambda.github.io/quints/schema/customers.schema.json
 # Customer registry — invoices reference these entries by key. A customer
 # is a flat entry, or a dated `versions` history for address changes.
 acme:

{quints-0.3.0 → quints-0.4.1}/examples/invoicing/globex-2026-08.yaml

@@ -1,3 +1,4 @@
+# yaml-language-server: $schema=https://sealambda.github.io/quints/schema/invoice.schema.json
 # Sample export invoice — foreign currency, reverse charge, no QR part.
 # Ties to the ^INV2026015 booking in books/2026.bean (500.00 EUR).
 number: INV2026015

{quints-0.3.0 → quints-0.4.1}/examples/invoicing/issuer.yaml

@@ -1,3 +1,4 @@
+# yaml-language-server: $schema=https://sealambda.github.io/quints/schema/issuer.schema.json
 # Issuer identity for `quints invoice` — name, address, VAT ID, and one
 # bank account per invoicing currency. Sample data: replace the VAT ID
 # and IBANs with your own before issuing a real invoice.

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

@@ -1,6 +1,6 @@
 [project]
 name = "quints"
-version = "0.3.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.1/src/quints/__init__.py

@@ -0,0 +1,7 @@
+"""quints — Swiss VAT & accounting for plain-text (beancount) books."""
+
+from importlib.metadata import version
+
+# Derived from the installed distribution (pyproject.toml is the single
+# source) — a hardcoded string here drifted from the released version once.
+__version__ = version("quints")

{quints-0.3.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,
 )
@@ -57,11 +62,26 @@ app = typer.Typer(
 )
 
 
+def _print_version(value: bool) -> None:
+    if value:
+        from . import __version__
+
+        typer.echo(__version__)
+        raise typer.Exit()
+
+
 @app.callback()
-def _main(
+def root(
     config: Path | None = typer.Option(
         None, "--config", help="quints.toml path (default: ./quints.toml, else built-in defaults)."
     ),
+    version: bool = typer.Option(
+        False,
+        "--version",
+        help="Print the quints version and exit.",
+        callback=_print_version,
+        is_eager=True,
+    ),
 ):
     config_mod.set_path(config)
 
@@ -88,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
@@ -111,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
 
@@ -520,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 "
@@ -593,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(
@@ -702,7 +727,10 @@ def check(
 def invoice(
     data: Path = typer.Argument(..., help="Invoice file (.yaml/.toml/.json)."),
     out: Path | None = typer.Option(
-        None, "--out", "-o", help="Output PDF (default: <number>.pdf)."
+        None,
+        "--out",
+        "-o",
+        help="Output PDF (default: filed under documents/<income account>/).",
     ),
     issuer: Path = typer.Option(
         Path("invoicing/issuer.yaml"), "--issuer", help="Issuer config (.yaml/.toml/.json)."
@@ -734,7 +762,12 @@ def invoice(
     registry = m.load_customers(customers) if customers.exists() else None
     inv = m.load_invoice(data, registry)
     iss = m.load_issuer(issuer)
-    out = out or Path(f"{inv.number}.pdf")
+    if out is None:
+        # File the PDF the way beancount documents are filed: under the income
+        # account's folder, date-prefixed, next to the ledger's other evidence.
+        cfg = config_mod.get()
+        account = cfg.income_export if inv.kind == "export" else cfg.income_domestic
+        out = m.document_path(inv, account)
     path, totals, payload = r.render(inv, iss, out)
 
     qr_ok = None
@@ -766,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)}"
                 )
@@ -774,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 "
@@ -789,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,
@@ -808,7 +846,9 @@ def schema(
     """Write JSON Schemas for the invoice, issuer, and customers files.
 
     Point an editor at them (yaml-language-server modeline) for completion
-    and validation; any future UI can consume the same contract."""
+    and validation; any future UI can consume the same contract. The same
+    schemas are published on the docs site, so scaffolded YAMLs reference
+    them without running this command."""
     import json as _json
 
     from .invoice import model as m
@@ -822,6 +862,7 @@ def schema(
         path = out / f"{name}.schema.json"
         path.write_text(_json.dumps(mdl.model_json_schema(), indent=2) + "\n")
         ui.console.print(f"[ok]Wrote[/] {path}")
+    ui.console.print(f"[muted]Also hosted at {config_mod.DOCS_URL}/schema/[/]")
 
 
 @app.command()
@@ -845,6 +886,11 @@ def init(
     answers_file: Path | None = typer.Option(
         None, "--answers", help="TOML answer-file for non-interactive scaffolding."
     ),
+    use_git: bool = typer.Option(
+        True,
+        "--git/--no-git",
+        help="git init + commit the pristine scaffold (skipped inside an existing repo).",
+    ),
     force: bool = typer.Option(False, "--force", help="Overwrite existing files."),
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip prompts; accept defaults."),
     as_json: bool = typer.Option(False, "--json", help="Machine-readable output."),
@@ -908,14 +954,18 @@ def init(
         typer.secho(f"ERROR: {e}", fg="red", err=True)
         raise typer.Exit(1) from None
     result = init_mod.write(directory, files, force=force)
+    git_result = init_mod.init_git(directory) if use_git and result.written else None
 
     if as_json:
+        import dataclasses
+
         _json_out(
             {
                 "directory": str(directory),
                 "entity": answers.entity_name,
                 "written": [str(p) for p in result.written],
                 "skipped": [str(p) for p in result.skipped],
+                "git": dataclasses.asdict(git_result) if git_result else None,
             }
         )
         return
@@ -923,6 +973,11 @@ def init(
         ui.console.print(f"[ok]created[/] {path}")
     for path in result.skipped:
         ui.console.print(f"[warn]exists, skipped[/] {path} (use --force to overwrite)")
+    if git_result:
+        if git_result.committed:
+            ui.console.print("[ok]git[/] initialised repository, committed the scaffold")
+        else:
+            ui.console.print(f"[warn]git[/] {git_result.detail}")
     if result.written and not result.skipped:
         ui.console.print(
             f"\nScaffolded [b]{answers.entity_name}[/] in {directory}. "

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

@@ -28,6 +28,11 @@ else:  # pragma: no cover
 
 DEFAULT_PATH = Path("quints.toml")
 
+# The published documentation site. The invoice/issuer/customers JSON Schemas
+# are hosted under <DOCS_URL>/schema/ (regenerated by `make docs`, sync-tested
+# in CI); `quints init` writes yaml-language-server modelines pointing there.
+DOCS_URL = "https://sealambda.github.io/quints"
+
 # Legal form → account-name component (Assets:CH:<component>:…). The keys are
 # the entity families the official KMU Kontenrahmen (veb.ch) prints Klasse-28
 # variants for: juristische Personen (gmbh, ag) and Einzelunternehmen;
@@ -115,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 _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, default) -> tuple[tuple[str, str], ...]:
-    if "accounts" not in section:
+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.3.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.3.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")))