beancount-cli 0.2.16__tar.gz → 0.2.17__tar.gz

{beancount_cli-0.2.16 → beancount_cli-0.2.17}/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.17] - 2026-09-28
+
+### Changed
+- CLI program name is now `bean` (shown in `--help` and `--version`).
+
+### Fixed
+- `price fetch --fill-gaps` now backfills interior gaps instead of behaving like `--update`; requires `beanprice2>=2.1.2`.
+- `price fetch` keeps running when one price source raises: failed jobs are reported, fetched prices are still written, and the run exits with a partial-failure code.
+- `price fetch` no longer crashes in the "Skipped N jobs" summary when a source returns no data.
+- `commodity import --target` no longer crashes when the target is given as a path string.
+- `price check-anomalies --help` no longer crashes on Python 3.14 (unescaped `%` in help text).
+
 ## [0.2.16] - 2026-06-12
 
 ### Changed

{beancount_cli-0.2.16 → beancount_cli-0.2.17}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: beancount-cli
-Version: 0.2.16
+Version: 0.2.17
 Summary: A CLI tool to manage Beancount ledgers
 Project-URL: Homepage, https://github.com/romamo/beancount-cli
 Project-URL: Repository, https://github.com/romamo/beancount-cli
@@ -22,7 +22,7 @@ Classifier: Topic :: Office/Business :: Financial :: Accounting
 Requires-Python: >=3.10
 Requires-Dist: agentyper==0.1.17
 Requires-Dist: beancount==3.2.3
-Requires-Dist: beanprice2>=2.1.0
+Requires-Dist: beanprice2>=2.1.2
 Requires-Dist: beanquery>=0.1.0
 Requires-Dist: pydantic-settings==2.14.1
 Requires-Dist: pydantic==2.13.4

{beancount_cli-0.2.16 → beancount_cli-0.2.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beancount-cli"
-version = "0.2.16"
+version = "0.2.17"
 description = "A CLI tool to manage Beancount ledgers"
 readme = "README.md"
 authors = [
@@ -13,7 +13,7 @@ dependencies = [
     "beanquery>=0.1.0",
     "pydantic==2.13.4",
     "python-dateutil>=2.8.2",
-    "beanprice2>=2.1.0",
+    "beanprice2>=2.1.2",
     "pydantic-settings==2.14.1",
     "agentyper==0.1.17",
 ]
@@ -86,3 +86,6 @@ extend-immutable-calls = ["agentyper.Argument", "agentyper.Option", "typer.Argum
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = ["E501"]
 
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

beancount_cli-0.2.17/src/beancount_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.17"

{beancount_cli-0.2.16 → beancount_cli-0.2.17}/src/beancount_cli/cli.py

@@ -11,7 +11,7 @@ from beancount_cli.commands.root import check, format_cmd, tree
 from beancount_cli.commands.transaction import app as tx_app
 
 app = typer.Agentyper(
-    name="beancount-cli",
+    name="bean",
     version=__version__,
     help="Beancount CLI tool for managing ledgers.",
 )

{beancount_cli-0.2.16 → beancount_cli-0.2.17}/src/beancount_cli/commands/price.py

@@ -1,5 +1,6 @@
 import logging
 import sys
+from collections.abc import Iterable, Iterator
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import date, datetime
 from decimal import Decimal
@@ -65,7 +66,7 @@ def price_check_anomalies(
         None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
     ),
     threshold: float = typer.Option(
-        1.0, "--threshold", "-t", help="Minimum change percentage as decimal (1.0 = 100%)"
+        1.0, "--threshold", "-t", help="Minimum change percentage as decimal (1.0 = 100%%)"
     ),
     max_days: int = typer.Option(
         7, "--max-days", "-d", help="Maximum days between consecutive prices"
@@ -139,6 +140,7 @@ def price_fetch(
     label = ", ".join(str(f) for f in files_to_load)
     error_console.print(f"Fetching prices for {label}...", highlight=False)
 
+    errored_jobs: list[tuple[bp_price.DatedPrice, str]] = []
     try:
         cache_path = Path(gettempdir()) / "bean-price.cache"
         bp_price.setup_cache(str(cache_path), clear_cache=False)
@@ -193,43 +195,39 @@ def price_fetch(
         failed_jobs = []
         redundant_count = 0
         try:
-            with ThreadPoolExecutor(max_workers=min(8, len(jobs))) as executor:
-                future_to_job = {executor.submit(bp_price.fetch_price, job): job for job in jobs}
-
-                for future in as_completed(future_to_job):
-                    job = future_to_job[future]
-                    price_entry = future.result()
-                    if price_entry:
-                        price_entry = price_entry._replace(
-                            amount=price_entry.amount._replace(
-                                number=price_entry.amount.number.quantize(Decimal("1.000000"))
-                            )
+            for job, price_entry, error in _fetch_price_jobs(jobs):
+                if error is not None:
+                    errored_jobs.append((job, error))
+                elif price_entry:
+                    assert price_entry.amount.number is not None  # beanprice always sets it
+                    price_entry = price_entry._replace(
+                        amount=price_entry.amount._replace(
+                            number=price_entry.amount.number.quantize(Decimal("1.000000"))
                         )
+                    )
 
-                        if (price_entry.date, price_entry.currency) not in existing_prices:
-                            new_price_entries.append(price_entry)
-                            existing_prices.add((price_entry.date, price_entry.currency))
-                            print(printer.format_entry(price_entry), end="")
-                            sys.stdout.flush()
-                        else:
-                            redundant_count += 1
-                            logging.debug(
-                                "Redundant: %s", printer.format_entry(price_entry).strip()
-                            )
+                    if (price_entry.date, price_entry.currency) not in existing_prices:
+                        new_price_entries.append(price_entry)
+                        existing_prices.add((price_entry.date, price_entry.currency))
+                        print(printer.format_entry(price_entry), end="")
+                        sys.stdout.flush()
                     else:
-                        failed_jobs.append(job)
+                        redundant_count += 1
+                        logging.debug("Redundant: %s", printer.format_entry(price_entry).strip())
+                else:
+                    failed_jobs.append(job)
         except KeyboardInterrupt:
             error_console.print("\n[yellow]Interrupt received. Stopping fetch...[/yellow]")
 
+        filtered_prices = []
         if update and not dry_run and new_price_entries:
             filtered_prices, _ = bp_price.filter_redundant_prices(new_price_entries, entries)
-
             if not filtered_prices:
                 error_console.print(
                     "[yellow]All fetched prices are already in the ledger.[/yellow]"
                 )
-                return
 
+        if filtered_prices:
             prices_output = "".join(printer.format_entry(p) for p in filtered_prices)
 
             # Resolve target price file.
@@ -272,20 +270,64 @@ def price_fetch(
             )
 
         if failed_jobs:
-            failed_info = ", ".join(f"{j.currency} on {j.date}" for j in failed_jobs[:5])
-            if len(failed_jobs) > 5:
-                failed_info += f" (+{len(failed_jobs) - 5} more)"
+            failed_info = _summarize(_describe_job(j) for j in failed_jobs)
             error_console.print(
                 f"[yellow]Skipped {len(failed_jobs)} jobs with no data from source: {failed_info}[/yellow]"
             )
 
-        if not new_price_entries and not failed_jobs and not redundant_count:
+        if errored_jobs:
+            errored_info = _summarize(f"{_describe_job(j)} ({e})" for j, e in errored_jobs)
+            error_console.print(
+                f"[yellow]Skipped {len(errored_jobs)} jobs with source errors: {errored_info}[/yellow]",
+                highlight=False,
+            )
+
+        if not new_price_entries and not failed_jobs and not errored_jobs and not redundant_count:
             error_console.print("[yellow]No new prices found.[/yellow]")
 
     except Exception as e:
         error_console.print(f"[red]Error fetching prices: {e}[/red]")
         sys.exit(typer.EXIT_SYSTEM)
 
+    if errored_jobs:
+        sys.exit(typer.ExitCode.PARTIAL_FAILURE)
+
+
+def _fetch_price_job(job: bp_price.DatedPrice) -> tuple[data.Price | None, str | None]:
+    """Fetch one job, returning (price, error) instead of raising on a source failure.
+
+    Price sources signal fetch errors with ValueError (the beanprice source
+    convention) and transport failures with OSError (urllib, requests and
+    curl_cffi errors all derive from it). Anything else is a bug and propagates.
+    """
+    try:
+        return bp_price.fetch_price(job), None
+    except (ValueError, OSError) as exc:
+        logging.error("Error fetching %s: %s", bp_price.format_dated_price_str(job), exc)
+        return None, str(exc)
+
+
+def _fetch_price_jobs(
+    jobs: list[bp_price.DatedPrice],
+) -> Iterator[tuple[bp_price.DatedPrice, data.Price | None, str | None]]:
+    """Fetch jobs concurrently, yielding (job, price, error) as each completes."""
+    with ThreadPoolExecutor(max_workers=min(8, len(jobs))) as executor:
+        future_to_job = {executor.submit(_fetch_price_job, job): job for job in jobs}
+        for future in as_completed(future_to_job):
+            yield future_to_job[future], *future.result()
+
+
+def _describe_job(job: bp_price.DatedPrice) -> str:
+    return f"{job.base} on {job.date or 'latest'}"
+
+
+def _summarize(items: Iterable[str], limit: int = 5) -> str:
+    items = list(items)
+    info = ", ".join(items[:limit])
+    if len(items) > limit:
+        info += f" (+{len(items) - limit} more)"
+    return info
+
 
 def _resolve_price_jobs(
     entries: list[data.Directive],
@@ -295,7 +337,9 @@ def _resolve_price_jobs(
     fill_gaps: bool,
 ) -> list:
     if update or fill_gaps:
-        return bp_price.get_price_jobs_up_to_date(entries, date_last=date_last, inactive=inactive)
+        return bp_price.get_price_jobs_up_to_date(
+            entries, date_last=date_last, inactive=inactive, fill_gaps=fill_gaps
+        )
     return bp_price.get_price_jobs_at_date(entries, date=None, inactive=inactive)
 
 

{beancount_cli-0.2.16 → beancount_cli-0.2.17}/src/beancount_cli/services.py

@@ -816,7 +816,9 @@ class CommodityService:
         dry_run: bool = False,
     ) -> tuple[list[CommodityImportResult], Path | None]:
         self.ledger_service.load()
-        commodities_file = output_file or self.ledger_service.get_commodities_file()
+        commodities_file = (
+            Path(output_file) if output_file else self.ledger_service.get_commodities_file()
+        )
         if commodities_file is not None and not commodities_file.exists():
             raise FileNotFoundError(f"commodities_file not found: {commodities_file}")
 

beancount_cli-0.2.17/tests/fake_price_source.py

@@ -0,0 +1,33 @@
+"""A beanprice source whose behaviour is chosen by the ticker, for price fetch tests.
+
+Tickers: OK returns a price, NODATA returns None, BROKEN raises OSError (a
+transport failure), BUG raises RuntimeError (a programming error).
+"""
+
+import datetime
+from decimal import Decimal
+
+from beanprice import source
+
+
+class Source(source.Source):
+    def get_latest_price(self, ticker: str) -> source.SourcePrice | None:
+        return self._price(ticker)
+
+    def get_historical_price(
+        self, ticker: str, time: datetime.datetime
+    ) -> source.SourcePrice | None:
+        return self._price(ticker)
+
+    def _price(self, ticker: str) -> source.SourcePrice | None:
+        match ticker:
+            case "OK":
+                now = datetime.datetime.now(datetime.timezone.utc)
+                return source.SourcePrice(Decimal("1.5"), now, "USD")
+            case "NODATA":
+                return None
+            case "BROKEN":
+                raise OSError("connection reset by peer")
+            case "BUG":
+                raise RuntimeError("source bug")
+        raise AssertionError(f"unknown test ticker {ticker}")

{beancount_cli-0.2.16 → beancount_cli-0.2.17}/tests/smoke_test.py

@@ -29,7 +29,7 @@ def test_smoke():
         check=False,
     )
     assert result.returncode == 0
-    assert "beancount-cli" in result.stdout
+    assert result.stdout.startswith("bean ")
 
     # 3. Check transaction schema command
     result = subprocess.run(

beancount_cli-0.2.17/tests/test_price_fetch_errors.py

@@ -0,0 +1,93 @@
+"""Regression tests for `price fetch` source errors (issue #10).
+
+A source raising for one job must not abort the run: the error is recorded,
+the remaining jobs are fetched and written, and the run exits with
+PARTIAL_FAILURE.
+"""
+
+import os
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+import fake_price_source
+import pytest
+from beanprice import price as bp_price
+
+from beancount_cli.commands.price import _fetch_price_job
+
+TESTS_DIR = Path(__file__).parent
+
+LEDGER = """
+    option "operating_currency" "USD"
+
+    2026-01-01 commodity GOOD
+      price: "USD:fake_price_source/OK"
+    2026-01-01 commodity FAIL
+      price: "USD:fake_price_source/BROKEN"
+    2026-01-01 commodity NONE
+      price: "USD:fake_price_source/NODATA"
+
+    2026-01-01 open Assets:Broker
+    2026-01-01 open Equity:Opening
+
+    2026-01-02 * "Buy"
+      Assets:Broker   1 GOOD {1 USD}
+      Assets:Broker   1 FAIL {1 USD}
+      Assets:Broker   1 NONE {1 USD}
+      Equity:Opening -3 USD
+"""
+
+
+def _run_fetch(tmp_path: Path, *args: str) -> subprocess.CompletedProcess:
+    ledger = tmp_path / "main.beancount"
+    ledger.write_text(textwrap.dedent(LEDGER))
+    env = {
+        **os.environ,
+        "PYTHONPATH": os.pathsep.join([str(TESTS_DIR), os.environ.get("PYTHONPATH", "")]),
+        "TMPDIR": str(tmp_path),  # isolate the bean-price cache
+    }
+    env.pop("BEANCOUNT_FILE", None)
+    return subprocess.run(
+        [sys.executable, "-m", "beancount_cli.cli", "price", "fetch", str(ledger), *args],
+        capture_output=True,
+        text=True,
+        env=env,
+        check=False,
+    )
+
+
+def test_source_error_does_not_abort_other_jobs(tmp_path):
+    result = _run_fetch(tmp_path)
+
+    assert result.returncode == 2, result.stderr  # PARTIAL_FAILURE
+    assert "price GOOD" in result.stdout
+    assert "Error fetching prices" not in result.stderr
+    assert "Skipped 1 jobs with source errors: FAIL" in result.stderr
+    assert "connection reset by peer" in result.stderr
+    assert "Skipped 1 jobs with no data from source: NONE" in result.stderr
+
+
+def test_update_writes_prices_despite_source_error(tmp_path):
+    result = _run_fetch(tmp_path, "--update")
+
+    assert result.returncode == 2, result.stderr
+    ledger_text = (tmp_path / "main.beancount").read_text()
+    assert "price GOOD" in ledger_text
+    assert "price FAIL" not in ledger_text
+
+
+def _job(ticker: str) -> bp_price.DatedPrice:
+    return bp_price.DatedPrice(
+        "X", "USD", None, [bp_price.PriceSource(fake_price_source, ticker, False)]
+    )
+
+
+def test_fetch_price_job_records_transport_error():
+    assert _fetch_price_job(_job("BROKEN")) == (None, "connection reset by peer")
+
+
+def test_fetch_price_job_propagates_unexpected_errors():
+    with pytest.raises(RuntimeError, match="source bug"):
+        _fetch_price_job(_job("BUG"))

beancount_cli-0.2.17/tests/test_price_fill_gaps.py

@@ -0,0 +1,61 @@
+"""Regression tests for `price fetch --fill-gaps` (issue #9).
+
+--fill-gaps must be forwarded to beanprice so interior gaps in a commodity's
+price history are backfilled even when its latest price is already current.
+"""
+
+import textwrap
+from datetime import date
+
+import pytest
+from beancount import loader
+
+from beancount_cli.commands.price import _resolve_price_jobs
+
+
+@pytest.fixture
+def gapped_entries():
+    entries, errors, _ = loader.load_string(
+        textwrap.dedent("""
+            option "operating_currency" "USD"
+
+            2026-07-01 commodity ACME
+              price: "USD:beanprice.sources.yahoo/ACME"
+
+            2026-07-01 open Assets:Broker:ACME ACME
+            2026-07-01 open Assets:Cash USD
+
+            2026-07-01 * "Buy"
+              Assets:Broker:ACME  10 ACME {100 USD}
+              Assets:Cash        -1000 USD
+
+            2026-07-15 price ACME 100 USD
+            2026-09-28 price ACME 110 USD
+        """)
+    )
+    assert not errors, errors
+    return entries
+
+
+def _acme_dates(jobs) -> set[date]:
+    return {j.date for j in jobs if (j.base, j.quote) == ("ACME", "USD")}
+
+
+def test_update_without_fill_gaps_skips_interior_gap(gapped_entries):
+    jobs = _resolve_price_jobs(
+        gapped_entries, date(2026, 9, 29), False, update=True, fill_gaps=False
+    )
+    assert _acme_dates(jobs) == set()
+
+
+def test_fill_gaps_backfills_interior_gap(gapped_entries):
+    jobs = _resolve_price_jobs(
+        gapped_entries, date(2026, 9, 29), False, update=True, fill_gaps=True
+    )
+    dates = _acme_dates(jobs)
+    assert date(2026, 7, 16) in dates
+    assert date(2026, 9, 25) in dates
+    # Existing prices and weekends are not refetched
+    assert date(2026, 7, 15) not in dates
+    assert date(2026, 9, 28) not in dates
+    assert date(2026, 7, 18) not in dates

beancount_cli-0.2.16/src/beancount_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.16"