quints 0.4.0__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quints
-Version: 0.4.0
+Version: 0.5.0
 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.5.0}/examples/quints.toml

@@ -12,6 +12,10 @@ operating_currency = "CHF"
 main = "main.bean"
 prices = "prices.bean"
 
+# `quints prices sync` reads the commodity price metadata in
+# commodities.bean (same as bean-price). A [prices] section here only
+# matters for ledgers that declare none — see the FX guide.
+
 [accounts]
 entity_marker = ":CH:GmbH:"         # scopes KMU statements and the plugin
 input_vat = "Assets:CH:GmbH:Tax:InputVAT"

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

@@ -1,6 +1,6 @@
 [project]
 name = "quints"
-version = "0.4.0"
+version = "0.5.0"
 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"
@@ -30,6 +30,11 @@ dependencies = [
 [project.scripts]
 quints = "quints.cli:main"
 
+[tool.deptry.per_rule_ignores]
+# The default price source: `prices sync` resolves it by module name at
+# runtime (importlib), so deptry sees no static import.
+DEP002 = ["beanprice-bazg"]
+
 [dependency-groups]
 dev = ["pytest>=8"]
 

{quints-0.4.0 → quints-0.5.0}/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)."
     ),
@@ -81,7 +86,10 @@ def _main(
     config_mod.set_path(config)
 
 
-prices_app = typer.Typer(no_args_is_help=True, help="Price database (BAZG daily CHF rates).")
+prices_app = typer.Typer(
+    no_args_is_help=True,
+    help="Price database (daily FX rates from any beanprice source; BAZG by default).",
+)
 app.add_typer(prices_app, name="prices")
 report_app = typer.Typer(
     no_args_is_help=True,
@@ -103,7 +111,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 +136,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
 
@@ -330,20 +340,31 @@ def match(
 
 @prices_app.command("sync")
 def prices_sync(
-    out: Path = typer.Option(
-        ledger.DEFAULT_PRICES, "--out", help="Price file (default: prices.bean)."
+    out: Path | None = typer.Option(
+        None, "--out", help="Price file (default: [ledger].prices from quints.toml, prices.bean)."
     ),
     from_: str | None = typer.Option(
         None,
         "--from",
-        help="Repair: re-scan from this date and fill ANY missing days (heals interior gaps).",
+        help="Repair: re-check every day from this date, even days already verified.",
+    ),
+    source: str | None = typer.Option(
+        None,
+        "--source",
+        help="beanprice source module (default: [prices].source from quints.toml, beanprice_bazg).",
     ),
     as_json: bool = typer.Option(False, "--json", help="Machine-readable output."),
 ):
-    """Fetch new BAZG daily CHF rates into the price file (full precision, gap-aware).
-
-    Without --from: extend each currency forward to today (fast, daily use).
-    With --from DATE: re-scan the whole range and fill any missing days.
+    """Fetch daily rates into the price file (full precision, resumable, gap-aware).
+
+    What to fetch comes from the ledger's commodity `price:` metadata — the
+    same declarations bean-price reads — or, when the ledger declares none,
+    from [prices] in quints.toml. Every run extends each currency forward to
+    today AND fills interior gaps; days the source has no rate for (weekends,
+    holidays) are checked once and recorded as verified in the file header.
+    The file is written as rates arrive, so an interrupted sync resumes where
+    it left off.
+    With --from DATE: re-check the whole range, ignoring the verified record.
     """
     from rich.progress import (
         BarColumn,
@@ -354,10 +375,24 @@ def prices_sync(
         TimeRemainingColumn,
     )
 
+    cfg = config_mod.get()
+    out = out if out is not None else cfg.ledger_prices
     repair = _parse_date(from_) if from_ else None
-    # BAZG has no bulk endpoint — the fetch is one request per calendar day per
-    # currency, so a backfill takes a while: show a live per-currency bar
-    # (stderr, transient) unless the caller asked for machine-readable output.
+    # bean-price mode: commodity `price:` metadata declares what to fetch.
+    # --source forces config mode; a metadata-less ledger falls back to it too.
+    jobs = None
+    if source is None and cfg.ledger_main.exists():
+        entries, _errors = ledger.load_entries(cfg.ledger_main)
+
+        def bad_meta(ccy: str, message: str) -> None:
+            typer.secho(
+                f"{ccy}: skipping unusable price metadata — {message}", fg="yellow", err=True
+            )
+
+        jobs = prices_mod.jobs_from_ledger(entries, on_error=bad_meta) or None
+    # Sources without a bulk endpoint fetch one request per day per currency,
+    # so a backfill takes a while: show a live per-currency bar (stderr,
+    # transient) unless the caller asked for machine-readable output.
     with Progress(
         TextColumn("[progress.description]{task.description}"),
         BarColumn(),
@@ -375,7 +410,16 @@ def prices_sync(
                 tasks[ccy] = bars.add_task(ccy, total=total)
             bars.update(tasks[ccy], completed=done)
 
-        result = prices_mod.sync(out, repair_from=repair, progress=on_progress)
+        result = prices_mod.sync(
+            out,
+            repair_from=repair,
+            currencies=cfg.prices_currencies,
+            source=source if source is not None else cfg.prices_source,
+            quote=cfg.operating_currency,
+            tickers=dict(cfg.prices_tickers),
+            progress=on_progress,
+            jobs=jobs,
+        )
     if as_json:
         _json_out(
             {
@@ -383,15 +427,27 @@ def prices_sync(
                 "wrote": result.wrote,
                 "added": result.added,
                 "per_currency": {
-                    ccy: {"added": added, "had_through": last}
-                    for ccy, (added, last) in result.per_currency.items()
+                    ccy: {
+                        "added": s.added,
+                        "healed": s.healed,
+                        "unavailable": s.unavailable,
+                        "had_through": s.last,
+                    }
+                    for ccy, s in result.per_currency.items()
                 },
             }
         )
         return
-    for ccy, (added, last) in result.per_currency.items():
-        where = f"had through {last}" if last else "was empty"
-        typer.echo(f"{ccy}: +{added} rate(s) ({where}).")
+    for ccy, s in result.per_currency.items():
+        where = f"had through {s.last}" if s.last else "was empty"
+        healed = f", {s.healed} gap day(s) healed" if s.healed else ""
+        typer.echo(f"{ccy}: +{s.added} rate(s){healed} ({where}).")
+        if s.unavailable:
+            typer.secho(
+                f"{ccy}: {s.unavailable} day(s) unavailable from the source — retried next sync.",
+                fg="yellow",
+                err=True,
+            )
     if result.wrote:
         typer.secho(f"Wrote {result.added} new price(s) to {out.name} (sorted).", fg="green")
     else:
@@ -535,11 +591,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 +666,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 +848,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 +858,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 +876,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.5.0}/src/quints/config.py

@@ -112,6 +112,10 @@ class Config:
     rounding_income: str = "Income:CH:GmbH:Rounding"
     income_domestic: str = "Income:CH:GmbH:Consulting:External:Domestic"
     income_export: str = "Income:CH:GmbH:Consulting:External:Export"
+    # [prices]
+    prices_source: str = "beanprice_bazg"  # beanprice source module for `prices sync`
+    prices_currencies: tuple[str, ...] = ("USD", "EUR")  # priced against operating_currency
+    prices_tickers: tuple[tuple[str, str], ...] = ()  # currency -> source ticker, when they differ
     # [report]
     report_language: str = "en"
     # [import.*] — statement importers (plan 2); None = not configured
@@ -120,67 +124,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",
@@ -197,6 +214,15 @@ def _from_mapping(raw: dict) -> Config:
         "income_export",
     ):
         take(accounts, key, key)
+    prices_ = section("prices")
+    take(prices_, "source", "prices_source")
+    if "currencies" in prices_:
+        currencies = prices_["currencies"]
+        if isinstance(currencies, list):
+            updates["prices_currencies"] = tuple(str(c) for c in currencies)
+    tickers = prices_.get("tickers")
+    if isinstance(tickers, dict):
+        updates["prices_tickers"] = tuple(sorted((str(k), str(v)) for k, v in tickers.items()))
     take(report, "language", "report_language")
     updates.update(_import_sections(raw))
     return replace(cfg, **updates)

{quints-0.4.0 → quints-0.5.0}/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.5.0}/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")))