quints 0.2.0__tar.gz → 0.3.0__tar.gz

{quints-0.2.0 → quints-0.3.0}/.gitignore

@@ -6,6 +6,7 @@ build/
 *.egg-info/
 .pytest_cache/
 .ruff_cache/
+site/
 .env
 .DS_Store
 .claude/settings.local.json

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quints
-Version: 0.2.0
+Version: 0.3.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
@@ -11,7 +11,7 @@ Requires-Dist: beancount>=3.2.0
 Requires-Dist: beangulp-mt940>=0.1.0
 Requires-Dist: beangulp-stripe>=0.1.0
 Requires-Dist: beangulp-wise[sca]>=0.1.0
-Requires-Dist: beanprice-bazg>=0.1.0
+Requires-Dist: beanprice-bazg>=0.2.0
 Requires-Dist: fava>=1.30
 Requires-Dist: pydantic>=2.7
 Requires-Dist: python-stdnum>=1.20
@@ -27,7 +27,7 @@ Description-Content-Type: text/markdown
 
 Swiss VAT & accounting toolkit for plain-text ([beancount](https://github.com/beancount/beancount)) books.
 
-Everything a Swiss micro-company (GmbH/AG) needs on top of beancount + Fava:
+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
   transactions, VAT status, and Bezugsteuer (reverse-charge, Art. 45 ff. MWSTG)

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

@@ -2,7 +2,7 @@
 
 Swiss VAT & accounting toolkit for plain-text ([beancount](https://github.com/beancount/beancount)) books.
 
-Everything a Swiss micro-company (GmbH/AG) needs on top of beancount + Fava:
+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
   transactions, VAT status, and Bezugsteuer (reverse-charge, Art. 45 ff. MWSTG)

quints-0.3.0/examples/invoicing/acme-2026-07.yaml

@@ -0,0 +1,15 @@
+# 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.
+number: INV2026014
+kind: domestic
+currency: CHF
+issue_date: 2026-07-02
+supply: Juli 2026
+customer: acme
+items:
+  - description: Consulting — July
+    quantity: 1
+    unit_price: 1000.00
+    unit: Pauschal
+locale: de_CH

quints-0.3.0/examples/invoicing/customers.yaml

@@ -0,0 +1,15 @@
+# Customer registry — invoices reference these entries by key. A customer
+# is a flat entry, or a dated `versions` history for address changes.
+acme:
+  name: Acme AG
+  address:
+    - Bahnhofstrasse 1
+    - 8001 Zürich
+globex:
+  name: Globex Ltd
+  country: IE
+  # Reverse-charge exports must carry the customer's VAT number.
+  vat_id: IE1234567T
+  address:
+    - 1 Liffey Street
+    - Dublin 1

quints-0.3.0/examples/invoicing/globex-2026-08.yaml

@@ -0,0 +1,13 @@
+# Sample export invoice — foreign currency, reverse charge, no QR part.
+# Ties to the ^INV2026015 booking in books/2026.bean (500.00 EUR).
+number: INV2026015
+kind: export
+currency: EUR
+issue_date: 2026-08-05
+supply: August 2026
+customer: globex
+items:
+  - description: Export consulting
+    quantity: 1
+    unit_price: 500.00
+locale: en

quints-0.3.0/examples/invoicing/issuer.yaml

@@ -0,0 +1,16 @@
+# 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.
+name: Example GmbH
+address:
+  - Beispielstrasse 1
+  - 8000 Zürich
+vat_id: CHE-267.359.056 MWST
+email: billing@example.ch
+bank:
+  CHF:
+    # QR-IBAN (QR-IID variant) — a Swiss QR-bill with a QRR reference.
+    qr_iban: CH44 3199 9123 0008 8901 2
+  EUR:
+    # Regular IBAN — foreign transfers can't use the QR-bill scheme.
+    iban: CH93 0076 2011 6238 5295 7

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

@@ -1,6 +1,6 @@
 [project]
 name = "quints"
-version = "0.2.0"
+version = "0.3.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"
@@ -15,7 +15,7 @@ dependencies = [
     "beangulp-mt940>=0.1.0",
     "beangulp-stripe>=0.1.0",
     "beangulp-wise[sca]>=0.1.0",
-    "beanprice-bazg>=0.1.0",
+    "beanprice-bazg>=0.2.0",
     "fava>=1.30",
     "pydantic>=2.7",
     "python-stdnum>=1.20",

{quints-0.2.0 → quints-0.3.0}/src/quints/__init__.py

@@ -1,3 +1,3 @@
 """quints — Swiss VAT & accounting for plain-text (beancount) books."""
 
-__version__ = "0.1.0"
+__version__ = "0.3.0"

{quints-0.2.0 → quints-0.3.0}/src/quints/cli.py

@@ -330,8 +330,37 @@ def prices_sync(
     Without --from: extend each currency forward to today (fast, daily use).
     With --from DATE: re-scan the whole range and fill any missing days.
     """
+    from rich.progress import (
+        BarColumn,
+        MofNCompleteColumn,
+        Progress,
+        TaskID,
+        TextColumn,
+        TimeRemainingColumn,
+    )
+
     repair = _parse_date(from_) if from_ else None
-    result = prices_mod.sync(out, repair_from=repair)
+    # 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.
+    with Progress(
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        TextColumn("days"),
+        TimeRemainingColumn(),
+        console=ui.err_console,
+        transient=True,
+        disable=as_json,
+    ) as bars:
+        tasks: dict[str, TaskID] = {}
+
+        def on_progress(ccy: str, done: int, total: int) -> None:
+            if ccy not in tasks:
+                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)
     if as_json:
         _json_out(
             {

{quints-0.2.0 → quints-0.3.0}/src/quints/init.py

@@ -28,7 +28,9 @@ The compute layer (:func:`plan`) is presentation-free: answers in, an ordered
 list of :class:`ScaffoldFile` out, no I/O. :func:`write` does the I/O. Running
 :func:`plan` with ``include_samples=True`` produces the repo's ``examples/``
 project, which doubles as the CI smoke test — so the example is regenerated,
-never hand-maintained.
+never hand-maintained. The samples include an ``invoicing/`` set (issuer,
+customer registry, a domestic QR-bill and a reverse-charge export invoice)
+tied to the demo quarter's bookings, so ``quints invoice`` reconciles clean.
 """
 
 from __future__ import annotations
@@ -405,6 +407,108 @@ def _prices_bean(answers: Answers) -> str:
     )
 
 
+# ── invoicing samples ────────────────────────────────────────────────────────
+
+# Checksum-valid demo identifiers (stdnum-verified) — obviously not real.
+_SAMPLE_VAT_ID = "CHE-267.359.056 MWST"
+_SAMPLE_QR_IBAN = "CH44 3199 9123 0008 8901 2"  # QR-IID range 30000–31999
+_SAMPLE_IBAN = "CH93 0076 2011 6238 5295 7"
+_SAMPLE_CUSTOMER_VAT_ID = "IE1234567T"
+
+
+def _issuer_yaml(answers: Answers) -> str:
+    return "\n".join(
+        [
+            "# 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.",
+            f"name: {answers.entity_name}",
+            "address:",
+            "  - Beispielstrasse 1",
+            "  - 8000 Zürich",
+            f"vat_id: {_SAMPLE_VAT_ID}",
+            "email: billing@example.ch",
+            "bank:",
+            "  CHF:",
+            "    # QR-IBAN (QR-IID variant) — a Swiss QR-bill with a QRR reference.",
+            f"    qr_iban: {_SAMPLE_QR_IBAN}",
+            "  EUR:",
+            "    # Regular IBAN — foreign transfers can't use the QR-bill scheme.",
+            f"    iban: {_SAMPLE_IBAN}",
+            "",
+        ]
+    )
+
+
+def _customers_yaml(_answers: Answers) -> str:
+    return "\n".join(
+        [
+            "# Customer registry — invoices reference these entries by key. A customer",
+            "# is a flat entry, or a dated `versions` history for address changes.",
+            "acme:",
+            "  name: Acme AG",
+            "  address:",
+            "    - Bahnhofstrasse 1",
+            "    - 8001 Zürich",
+            "globex:",
+            "  name: Globex Ltd",
+            "  country: IE",
+            "  # Reverse-charge exports must carry the customer's VAT number.",
+            f"  vat_id: {_SAMPLE_CUSTOMER_VAT_ID}",
+            "  address:",
+            "    - 1 Liffey Street",
+            "    - Dublin 1",
+            "",
+        ]
+    )
+
+
+def _invoice_acme_yaml(answers: Answers) -> str:
+    year = _open_date(answers).year
+    return "\n".join(
+        [
+            f"# Sample domestic invoice — a Swiss QR-bill. It ties to the ^INV{year}014",
+            f"# booking in books/{year}.bean (net 1'000.00 + 8.1% VAT = 1'081.00), so",
+            "# `quints invoice` cross-checks it clean against the ledger.",
+            f"number: INV{year}014",
+            "kind: domestic",
+            "currency: CHF",
+            f"issue_date: {year}-07-02",
+            f"supply: Juli {year}",
+            "customer: acme",
+            "items:",
+            "  - description: Consulting — July",
+            "    quantity: 1",
+            "    unit_price: 1000.00",
+            "    unit: Pauschal",
+            "locale: de_CH",
+            "",
+        ]
+    )
+
+
+def _invoice_globex_yaml(answers: Answers) -> str:
+    year = _open_date(answers).year
+    return "\n".join(
+        [
+            "# Sample export invoice — foreign currency, reverse charge, no QR part.",
+            f"# Ties to the ^INV{year}015 booking in books/{year}.bean (500.00 EUR).",
+            f"number: INV{year}015",
+            "kind: export",
+            "currency: EUR",
+            f"issue_date: {year}-08-05",
+            f"supply: August {year}",
+            "customer: globex",
+            "items:",
+            "  - description: Export consulting",
+            "    quantity: 1",
+            "    unit_price: 500.00",
+            "locale: en",
+            "",
+        ]
+    )
+
+
 # ── project metadata rendering ───────────────────────────────────────────────
 
 
@@ -625,6 +729,16 @@ def plan(answers: Answers) -> list[ScaffoldFile]:
     """Answers → the ordered set of files to materialise. Pure, no I/O."""
     _validate(answers)
     year = _open_date(answers).year
+    invoicing: list[ScaffoldFile] = []
+    if answers.include_samples:
+        # One QR-bill and one export invoice, reconciling against the sample
+        # quarter — so `quints invoice` is testable out of the box.
+        invoicing = [
+            ScaffoldFile(Path("invoicing/issuer.yaml"), _issuer_yaml(answers)),
+            ScaffoldFile(Path("invoicing/customers.yaml"), _customers_yaml(answers)),
+            ScaffoldFile(Path(f"invoicing/acme-{year}-07.yaml"), _invoice_acme_yaml(answers)),
+            ScaffoldFile(Path(f"invoicing/globex-{year}-08.yaml"), _invoice_globex_yaml(answers)),
+        ]
     files = [
         ScaffoldFile(Path("quints.toml"), _quints_toml(answers)),
         ScaffoldFile(Path("pyproject.toml"), _pyproject_toml(answers)),
@@ -633,6 +747,7 @@ def plan(answers: Answers) -> list[ScaffoldFile]:
         ScaffoldFile(Path("commodities.bean"), _commodities_bean(answers)),
         ScaffoldFile(Path("prices.bean"), _prices_bean(answers)),
         ScaffoldFile(Path(f"books/{year}.bean"), _books_bean(answers)),
+        *invoicing,
         ScaffoldFile(Path("AGENTS.md"), _agents_md(answers)),
         ScaffoldFile(Path(".gitignore"), _gitignore()),
         ScaffoldFile(Path("inbox/.gitkeep"), ""),

{quints-0.2.0 → quints-0.3.0}/src/quints/prices.py

@@ -17,15 +17,45 @@ Unlike ``bean-price --update main.bean`` — which rounds through the ledger's
 from __future__ import annotations
 
 import re
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 from datetime import date as Date
 from datetime import datetime, timedelta, timezone
+from decimal import Decimal
 from pathlib import Path
+from typing import Protocol
 
 from beanprice_bazg.bazg import Source
 
 from . import ledger
 
+ProgressFn = Callable[[str, int, int], None]
+"""(currency, days_fetched, days_total) — called once up front and per day."""
+
+
+class PricePoint(Protocol):
+    """One day's rate — the shape of ``beanprice`` ``SourcePrice``."""
+
+    @property
+    def price(self) -> Decimal: ...
+    @property
+    def time(self) -> datetime: ...
+
+
+class SeriesSource(Protocol):
+    """The slice of ``beanprice_bazg.Source`` that :func:`sync` needs."""
+
+    def get_prices_series(
+        self,
+        ticker: str,
+        time_begin: datetime,
+        time_end: datetime,
+        /,
+        *,
+        progress: Callable[[Date], None] | None = None,
+    ) -> Sequence[PricePoint]: ...
+
+
 DEFAULT_BACKFILL_START = Date(2024, 1, 1)
 _PRICE_RE = re.compile(r"^(\d{4})-(\d{2})-(\d{2}) price (\w+)\s+(\S+) CHF\s*$")
 
@@ -42,6 +72,21 @@ def _utc(d: Date) -> datetime:
     return datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
 
 
+def _ticker(progress: ProgressFn | None, ccy: str, total: int) -> Callable[[Date], None] | None:
+    """Adapt the (ccy, done, total) callback to the source's per-day one."""
+    if progress is None:
+        return None
+    progress(ccy, 0, total)  # announce the currency before the first request
+    done = 0
+
+    def tick(_day: Date) -> None:
+        nonlocal done
+        done += 1
+        progress(ccy, done, total)
+
+    return tick
+
+
 def _read(out: Path):
     """Return (header_lines, {(ccy, date): price_str}) from an existing file."""
     header: list[str] = []
@@ -77,9 +122,10 @@ def sync(
     out: Path,
     repair_from: Date | None = None,
     today: Date | None = None,
-    currencies=ledger.PRICE_CURRENCIES,
+    currencies: Sequence[str] = ledger.PRICE_CURRENCIES,
     backfill_start: Date = DEFAULT_BACKFILL_START,
-    source=None,
+    source: SeriesSource | None = None,
+    progress: ProgressFn | None = None,
 ) -> SyncResult:
     if today is None:
         today = datetime.now(timezone.utc).date()
@@ -99,7 +145,8 @@ def sync(
 
         added = 0
         if start <= today:
-            for sp in src.get_prices_series(ccy, _utc(start), _utc(today)):
+            tick = _ticker(progress, ccy, total=(today - start).days + 1)
+            for sp in src.get_prices_series(ccy, _utc(start), _utc(today), progress=tick):
                 d = sp.time.date()
                 if (ccy, d) in entries:  # skip present (dedups weekend echoes + repair)
                     continue

quints-0.3.0/tests/test_docs.py

@@ -0,0 +1,112 @@
+"""Every quints command shown in the docs must actually run.
+
+The docs site (docs/**/*.md) and the README promise commands; this extracts
+them from the fenced code blocks and runs each page as a session — a fresh
+copy of the example project, commands executed in document order through the
+CLI (no --config/--file overrides — the same resolution a copy-paste gets),
+asserting a clean exit. If a documented command breaks — a renamed flag, a
+changed default — this fails, so the docs can't silently rot.
+
+Extraction rules (documented here because docs authors rely on them):
+
+- Only ``bash`` and ``console`` fences are scanned. In console blocks just
+  the ``$ ``-prefixed lines are commands (the rest is output); in bash
+  blocks every non-comment line is considered.
+- Only ``quints …`` and ``cd …`` lines execute. Anything else (uv, git,
+  pipx, …) is skipped — this suite runs offline and in-process.
+- A line containing a ``<placeholder>`` is skipped: it documents a pattern,
+  not a runnable invocation. Prefer concrete commands where possible.
+- An HTML comment containing ``no-test`` on the line above a fence skips the
+  whole block (network commands, credential-dependent fetches).
+- ``cd`` into a directory that doesn't exist (e.g. after a skipped
+  ``git clone``) is skipped too.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shlex
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+import pytest
+from typer.testing import CliRunner
+
+from quints.cli import app
+
+runner = CliRunner()
+REPO = Path(__file__).resolve().parents[3]
+EXAMPLES = Path(__file__).resolve().parents[1] / "examples"
+
+DOC_PAGES = sorted(p.relative_to(REPO) for p in (REPO / "docs").rglob("*.md"))
+PAGES = [Path("README.md"), *DOC_PAGES]
+
+_FENCE = re.compile(r"^```(\w*)")
+_NO_TEST = re.compile(r"<!--.*no-test.*-->")
+_PLACEHOLDER = re.compile(r"<[^>]+>")
+
+
+@dataclass(frozen=True)
+class _Command:
+    line: str  # verbatim doc line, for failure messages
+    argv: list[str]
+
+
+def _commands(text: str) -> list[_Command]:
+    """The quints/cd command sequence a reader would run for one page."""
+    commands: list[_Command] = []
+    lang: str | None = None  # inside a fence when not None
+    skip_block = False
+    prev = ""
+    for raw in text.splitlines():
+        line = raw.rstrip()
+        fence = _FENCE.match(line)
+        if fence and lang is None:
+            lang = fence.group(1)
+            skip_block = bool(_NO_TEST.search(prev))
+        elif line.startswith("```"):
+            lang = None
+        elif lang in ("bash", "console") and not skip_block:
+            cmd = line.strip()
+            if lang == "console":
+                if not cmd.startswith("$ "):
+                    continue  # output line
+                cmd = cmd[2:]
+            elif cmd.startswith("$ "):
+                cmd = cmd[2:]
+            if _PLACEHOLDER.search(cmd):
+                continue
+            argv = shlex.split(cmd, comments=True)
+            if argv and argv[0] in ("quints", "cd"):
+                commands.append(_Command(line=cmd, argv=argv))
+        prev = line
+    return commands
+
+
+@pytest.mark.parametrize("page", PAGES, ids=str)
+def test_documented_commands_run(
+    page: Path, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    commands = _commands((REPO / page).read_text())
+    proj = tmp_path / "example"
+    shutil.copytree(EXAMPLES, proj)
+    monkeypatch.chdir(proj)  # restores the original cwd on teardown
+    for cmd in commands:
+        if cmd.argv[0] == "cd":
+            if Path(cmd.argv[1]).is_dir():
+                os.chdir(cmd.argv[1])
+            continue
+        result = runner.invoke(app, cmd.argv[1:])
+        assert result.exit_code == 0, (
+            f"{page}: `{cmd.line}` exited {result.exit_code}:\n{result.output}"
+        )
+
+
+def test_extractor_sees_the_docs() -> None:
+    # If the docs move or the extractor breaks, the suite above would pass
+    # vacuously. Pin a floor: the site exists and yields real commands.
+    assert len(DOC_PAGES) >= 8, f"docs/ pages missing: found only {DOC_PAGES}"
+    total = sum(len(_commands((REPO / p).read_text())) for p in PAGES)
+    assert total >= 25, f"only {total} documented commands extracted — extractor broken?"

{quints-0.2.0 → quints-0.3.0}/tests/test_init.py

@@ -182,6 +182,38 @@ def test_generated_ledger_reports_expected_numbers(tmp_path: Path):
     assert open_inv[0].currency == "EUR"
 
 
+def test_sample_invoices_render_and_reconcile(tmp_path: Path):
+    # --samples must make the invoice generator testable out of the box: a
+    # domestic QR-bill and a reverse-charge export, both reconciling against
+    # the sample quarter's ^INV… bookings.
+    from quints.invoice import model as im
+    from quints.invoice import render as ir
+    from quints.invoice import verify as iv
+
+    answers = init.Answers(entity_name="Smoke GmbH", include_samples=True)
+    init.write(tmp_path, init.plan(answers))
+    main = tmp_path / "main.bean"
+    registry = im.load_customers(tmp_path / "invoicing/customers.yaml")
+    issuer = im.load_issuer(tmp_path / "invoicing/issuer.yaml")
+    assert issuer.name == "Smoke GmbH"
+
+    domestic = im.load_invoice(tmp_path / "invoicing/acme-2026-07.yaml", registry)
+    _path, totals, payload = ir.render(domestic, issuer, tmp_path / "acme.pdf")
+    assert payload is not None and payload.splitlines()[0] == "SPC"  # QR part present
+    cc = iv.cross_check(main, domestic, totals)
+    assert cc.found and cc.ok and cc.date_ok
+
+    export = im.load_invoice(tmp_path / "invoicing/globex-2026-08.yaml", registry)
+    _path, totals, payload = ir.render(export, issuer, tmp_path / "globex.pdf")
+    assert payload is None  # no QR-bill on a foreign invoice
+    cc = iv.cross_check(main, export, totals)
+    assert cc.found and cc.ok and cc.date_ok
+
+
+def test_no_invoicing_files_without_samples():
+    assert not any(f.path.parts[0] == "invoicing" for f in init.plan(init.Answers()))
+
+
 def test_cli_init_answers_file_and_force(tmp_path: Path):
     # Guards the CLI wiring: --answers is non-interactive, --json is stable,
     # and a second run without --force skips rather than clobbers.

{quints-0.2.0 → quints-0.3.0}/tests/test_prices_sync.py

@@ -1,7 +1,9 @@
 """Tests for the gap-aware price sync (no network — a fake source is injected)."""
 
+from collections.abc import Callable
 from datetime import date, timedelta
 from decimal import Decimal
+from pathlib import Path
 
 from beanprice_bazg.bazg import SourcePrice
 from quints import prices
@@ -13,11 +15,13 @@ class FakeSource:
     def __init__(self):
         self.calls = []
 
-    def get_prices_series(self, ccy, begin, end):
+    def get_prices_series(self, ccy, begin, end, progress: Callable[[date], None] | None = None):
         self.calls.append((ccy, begin.date(), end.date()))
         out, d = [], begin
         while d <= end:
             out.append(SourcePrice(Decimal("0.9"), d, "CHF"))
+            if progress is not None:
+                progress(d.date())
             d += timedelta(days=1)
         return out
 
@@ -71,6 +75,22 @@ def test_repair_heals_interior_gap_and_sorts(tmp_path):
     assert dates.count("2026-01-06") == 1  # no duplicates
 
 
+def test_progress_reports_each_day_per_currency(tmp_path: Path):
+    out = tmp_path / "prices.bean"
+    out.write_text(";; header\n")
+    seen = []
+    prices.sync(
+        out,
+        today=date(2026, 1, 3),
+        backfill_start=date(2026, 1, 1),
+        currencies=("EUR", "USD"),
+        source=FakeSource(),
+        progress=lambda ccy, done, total: seen.append((ccy, done, total)),
+    )
+    # Announced at 0, then one tick per fetched day, for each currency in turn.
+    assert seen == [(ccy, n, 3) for ccy in ("EUR", "USD") for n in range(4)]
+
+
 def test_header_preserved(tmp_path):
     out = tmp_path / "prices.bean"
     out.write_text(";; keep me\n;; and me\n\n2026-01-01 price EUR 0.9 CHF\n")

quints-0.2.0/examples/invoicing/acme-2026-07.yaml

@@ -1,19 +0,0 @@
-# Illustrative invoice for the example project — NOT emitted by `quints init`.
-# It ties to the ^INV2026014 booking in main.bean (net 1000 + 8.1% VAT = 1081),
-# so `quints invoice … --verify` reconciles the PDF against the ledger.
-number: INV2026014
-kind: domestic
-currency: CHF
-issue_date: 2026-07-02
-supply: Juli 2026
-customer:
-  name: Acme AG
-  address:
-    - Bahnhofstrasse 1
-    - 8001 Zürich
-items:
-  - description: Consulting — July
-    quantity: 1
-    unit_price: 1000.00
-    unit: Pauschal
-locale: de_CH

quints-0.2.0/examples/invoicing/issuer.yaml

@@ -1,12 +0,0 @@
-# Illustrative issuer for the example project — NOT emitted by `quints init`.
-# It's demo input for `quints invoice`; edit for your own entity.
-name: Example GmbH
-address:
-  - Beispielstrasse 1
-  - 8000 Zürich
-vat_id: CHE-267.359.056 MWST
-email: billing@example.ch
-bank:
-  CHF:
-    # QR-IBAN (QR-IID variant) — required for a Swiss QR-bill with a QRR reference.
-    qr_iban: CH44 3199 9123 0008 8901 2

quints-0.2.0/tests/test_docs.py

@@ -1,48 +0,0 @@
-"""Every command shown in the README must actually run.
-
-The README tells a newcomer to `cd packages/quints/examples` and run these
-commands. This copies that example to a scratch dir, changes into it, and runs
-each *literal* command through the CLI (no `--config`/`--file` overrides — the
-same resolution a copy-paste gets), asserting a clean exit. If a documented
-command breaks — a renamed flag, a changed default — this fails, so the docs
-can't silently rot. `prices sync` is excluded by design (it needs network);
-`init` is covered by test_init.
-"""
-
-import shutil
-from pathlib import Path
-
-import pytest
-from typer.testing import CliRunner
-
-from quints.cli import app
-
-runner = CliRunner()
-EXAMPLES = Path(__file__).resolve().parents[1] / "examples"
-
-# Exactly the runnable commands in README.md's "by the job" sections.
-README_COMMANDS: list[list[str]] = [
-    ["check"],
-    ["mwst", "-q", "2026-Q3"],
-    ["status"],
-    ["receivables"],
-    ["report", "bilanz", "--at", "2026-12-31"],
-    ["report", "erfolg", "--year", "2026"],
-    ["report", "statements", "--year", "2026", "--lang", "de"],
-    ["import", "ubs", "statements/ubs-2026.mt940"],
-    ["invoice", "invoicing/acme-2026-07.yaml"],
-    ["fx", "revalue", "--at", "2026-12-31"],
-]
-
-
-@pytest.mark.parametrize("cmd", README_COMMANDS, ids=lambda c: " ".join(c))
-def test_readme_command_runs(
-    cmd: list[str], tmp_path: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    proj = tmp_path / "example"
-    shutil.copytree(EXAMPLES, proj)
-    monkeypatch.chdir(proj)
-    result = runner.invoke(app, cmd)
-    assert result.exit_code == 0, (
-        f"`quints {' '.join(cmd)}` exited {result.exit_code}:\n{result.output}"
-    )