py-beacon-kit 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -96,3 +96,6 @@ fuzz-server.log
 # `git add -A` swept it into a commit once; an ignore rule is cheaper than
 # remembering.
 us_tickers.csv
+
+# Chart comparison results (pytest --mpl-results-path)
+chart-results/

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/CHANGELOG.md

@@ -8,6 +8,56 @@ Before 1.0, a breaking change raises the middle number, as in 0.1 to 0.2.
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-09-30
+
+Money in one currency across multi-currency indices, prices carried over gaps, expressions that refuse fields the data does not have, and engine state that survives. Two breaking changes: `data.actions` is gone from expressions, and some requests the engine cannot answer as put answer 422 instead of 404.
+
+### Added
+
+- `DataFetcher.fetch_prices` reads prices for several instruments at once, converted into one currency day by day under the dataset's FX policy.
+- `IndexResult.price_gaps` and `beacon.index.PriceGap`: the days a held name had no bar and was valued at its last close. `PriceGap` is still importable from `beacon.backtest`.
+- The asset view reports `currency`, which its returns, beta and tracking error are measured in (the index's), and `price_currency`, which its price series is in (the name's own).
+- A feature import's response says whether the rows were `saved` into the served store, and gives the new `data_version`.
+- `BacktestResult.get_annual_returns()`: calendar-year returns that compound to the whole run's return.
+- `TotalReturnSwap` takes `underlying_type` (`INDEX`, the default, `ETF` or `EQUITY`). It was always `INDEX`.
+- Each release from `GET /changelog` carries its `summary`, the prose between its heading and its first section.
+- A risk model request takes an optional `currency`, and a risk model and an optimisation run report the currency they were measured in.
+
+### Changed
+
+- Requests that cannot be answered as put answer 422 `INVALID_ARGUMENT` instead of 404 `DATA_NOT_FOUND`: an unknown price interval, an adjusted series without `CLOSE`, and an empty or oversized feature batch.
+- An expression with a field the data does not have is refused with `ExpressionError` by `universe.where`, `ExpressionScreen` and an index's `ExpressionRule`, naming the field and suggesting close matches. Before, it selected nothing.
+- `IndexDefinition` refuses an unknown calendar or rebalancing frequency when it is built, naming the valid values and suggesting close calendar codes. Before, the mistake surfaced only when rebalance dates were first computed.
+- The API schema states more of what it accepts: `since` on `/changelog` is a dotted version, and `/beacon/compare` needs at least two `ids`, each a valid identifier. These are now refused as `VALIDATION_ERROR` by the schema check. The boolean fields of a synthetic-data or import request no longer accept `0`, `1` or strings.
+
+### Removed
+
+- `data.actions` in expressions. No expression could read its fields, so every name was missing a value; it now raises `UnknownDatasetError`, and the field catalogue and `GET /data/fields` no longer list an `actions` namespace. Read corporate actions from the fetcher's `corporate_actions`.
+
+### Fixed
+
+- Money is compared in one currency wherever names are compared or added up. `LiquidityRule`'s traded-value floor, the engine's risk models, optimisation runs, the weights pane (drift, risk contributions, active risk), attribution and the asset view all read each name's prices in its own currency, so a multi-currency index mixed yen with dollars and left exchange-rate returns and risk out. They now convert into the index's currency.
+- An index values a held name with no bar on a session at its last close, as the backtest engine does, and lists the day in `IndexResult.price_gaps`. It used to value the name at zero, so the level dipped by the name's weight for the day and recovered when the bar returned.
+- An expression's `market_cap` inside an index is in the index's currency, as `MarketCapRule`'s bounds are. Outside an index it stays in USD.
+- `POST /data/features` now saves the rows into the served store when it is a folder, so they survive a restart, and changes `data_version` and sends a `data.freshness` event for `features`. Before, a client caching on `data_version` missed the change and a restart lost the rows.
+- The engine always keeps the saved results its views read: the latest backtest of each index, every optimisation run and the latest estimate of each risk model. The limit of 50 saved jobs now applies only to the rest, so a run of loads, refreshes or renders no longer makes those views answer 404.
+- `data.market.free_float` and `free_float_market_cap` in an expression carry the free float forward as far as the data's `free_float_backfill_days`, as every other read does, rather than 10 days.
+- Attribution for a capped index no longer fails when its window starts after the index's first rebalance. The cap drag is measured over the same periods as the contributions.
+- A cancelled dividend is no longer reinvested by a total-return index, counted in the trailing dividend and yield, or applied to adjusted closes; a cancelled split is no longer applied to adjusted closes either.
+- The engine checks for a token before it loads any data, so a missing token is reported at once rather than after a large store has loaded.
+- `http://127.0.0.1` and `http://[::1]` on any port are allowed origins, as `http://localhost` already was.
+- A wrong or missing token on the event socket closes it with code 1008 and a reason, as intended, instead of refusing the handshake with an HTTP 403 a browser cannot read.
+- `BacktestPlots.annual_returns` measures each year from the previous year's close, and the first from the initial capital. It measured each year from its own first close, so every year after the first lost its first day's return.
+- A chart drawn before `beacon.plot.use()` gets the light colours on matplotlib's white background, not the dark mode's.
+- `OptimisationPlots.frontier` starts the capital market line at the rate the frontier was traced at, unless another is passed, so the line is tangent.
+- The Excel reports accept a `pathlib.Path` as well as a string, and the holdings report writes `valuation_date` into its sheet instead of only logging it.
+- `futures_roll_return` uses 365-day years, like every other year fraction in the derivatives. It used 365.25, so its rates came out smaller than the rest by a factor of 365/365.25.
+- The sample dataset in `beacon.testing.dataset` stores its GBPUSD rate in `RATE`, so `fx_pairs` and the coverage view list it. A pair stored without `RATE` still converts but now logs a warning that it is not listed.
+- A report template with an unknown page setting answers 422 instead of 500, and so does a futures or swap price whose inputs overflow.
+- A plain `OPTIONS` request answers 405 with an `Allow` header listing every method its path supports. It listed only one route's methods on a path with several, such as `/data/features`. CORS preflights are unchanged.
+- The nightly API fuzz run passes again: it leaves out operations that start heavy work, and skips the check that a schema-valid request is accepted only where a rule spans fields or depends on the data.
+- Generating or extending synthetic data from an isolated engine (`python -I`, as the Beacon app runs it) keeps the child process isolated too, so it cannot load packages from the user's own site-packages.
+
 ## [0.2.0] - 2026-09-26
 
 Choose where the engine's data comes from: named stores, synthetic data you can extend to today, CSV and Excel import, and read-only Postgres. Also documentation at pybeacon.dev, and fixes to index levels and backtests around splits and delistings.
@@ -78,7 +128,8 @@ The first release.
 - An index or backtest never uses a price, rate or free float dated after the day it is working on.
 - Requires Python 3.11 or later.
 
-[Unreleased]: https://github.com/karanbh01/py-beacon/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/karanbh01/py-beacon/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/karanbh01/py-beacon/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/karanbh01/py-beacon/compare/v0.1.1...v0.2.0
 [0.1.1]: https://github.com/karanbh01/py-beacon/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/karanbh01/py-beacon/releases/tag/v0.1.0

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: py-beacon-kit
-Version: 0.2.0
+Version: 0.3.0
 Summary: End-to-end tool kit for index, ETF & Delta-1 derivatives development
 Project-URL: Homepage, https://pybeacon.dev
 Project-URL: Documentation, https://pybeacon.dev/library/

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/__init__.py

@@ -3,7 +3,7 @@
 py-beacon, an end-to-end toolkit for index, ETF, and Delta-1 derivatives
 development.
 """
-__version__ = "0.2.0"
+__version__ = "0.3.0"
 
 from . import derivatives
 from .derivatives import (

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/analysis/attribution.py

@@ -350,7 +350,8 @@ def cost_drag(total_costs: float,
 
 def cap_drag(capped_weights: dict[pd.Timestamp, dict[str, float]],
              uncapped_weights: dict[pd.Timestamp, dict[str, float]],
-             prices: pd.DataFrame) -> float:
+             prices: pd.DataFrame,
+             window: pd.Index | None = None) -> float:
     """What capping cost, or gained, over the window.
 
     The capped index's return minus the return of the same methodology left
@@ -365,27 +366,42 @@ def cap_drag(capped_weights: dict[pd.Timestamp, dict[str, float]],
     Args:
         capped_weights: Rebalance date -> capped weights.
         uncapped_weights: Rebalance date -> weights before capping.
-        prices: Constituent prices over the window.
+        prices: Constituent prices, from the first rebalance on. Weights
+            drift from the rebalance before each date, so the prices have to
+            reach back to it even when *window* starts later.
+        window: The dates to measure over, as for :func:`attribute`: the
+            return of each date after the first. None measures over every
+            date in *prices*.
 
     Returns:
         float: Capped total return minus uncapped total return.
     """
     asset_returns = prices.pct_change()
 
-    capped_return = _path_return(capped_weights, prices, asset_returns)
-    uncapped_return = _path_return(uncapped_weights, prices, asset_returns)
+    capped_return = _path_return(capped_weights, prices, asset_returns, window)
+    uncapped_return = _path_return(uncapped_weights, prices, asset_returns,
+                                   window)
 
     return capped_return - uncapped_return
 
 
 def _path_return(snapshots: dict[pd.Timestamp, dict[str, float]],
                  prices: pd.DataFrame,
-                 asset_returns: pd.DataFrame) -> float:
+                 asset_returns: pd.DataFrame,
+                 window: pd.Index | None = None) -> float:
     """Compounded return of an index following *snapshots*."""
+    # BN-258: drifted over all of *prices*, then cut to the window. Cutting
+    # the prices first left a rebalance before the window with no price to
+    # drift from, and the lookup raised KeyError.
     weights = drifted_weights(snapshots, prices)
+
+    if window is not None:
+        weights = weights.loc[weights.index.intersection(window)]
+
     assets = sorted(set(weights.columns) & set(asset_returns.columns))
 
-    periods = (weights[assets].shift(1) * asset_returns[assets]).sum(axis=1)
+    periods = (weights[assets].shift(1)
+               * asset_returns[assets].reindex(weights.index)).sum(axis=1)
     periods = periods.loc[weights[assets].shift(1).dropna(how="all").index]
 
     return float((1.0 + periods).prod() - 1.0)

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/backtest/__init__.py

@@ -13,11 +13,12 @@ and tracking against the target index. `BacktestModifier` subclasses such as
 `DriftThresholdModifier` can skip a rebalance or adjust its trades, and
 `BacktestAssetView` gives one asset's story through a backtest.
 """
+from ..index.result import PriceGap
 from ..portfolio.base import TradeInstruction
 from .asset_view import BacktestAssetView
 from .engine import BacktestEngine
 from .main import Backtest
-from .result import BacktestResult, PriceGap, RebalancePricing, UnfilledOrder
+from .result import BacktestResult, RebalancePricing, UnfilledOrder
 from .rules import BacktestModifier, DriftThresholdModifier
 
 __all__ = [

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/backtest/engine.py

@@ -9,7 +9,7 @@ import pandas as pd
 from ..data.corporate_actions import ratios_between
 from ..data.fetcher import DataFetcher
 from ..index.requirements import require_price_column
-from ..index.result import IndexResult
+from ..index.result import IndexResult, PriceGap
 from ..index.schedule import SESSION_UNIT, sessions
 from ..portfolio.base import CASH_TOLERANCE as PORTFOLIO_CASH_TOLERANCE
 
@@ -22,7 +22,6 @@ from .result import (
     BacktestResult,
     Book,
     IndexBooks,
-    PriceGap,
     RebalancePricing,
     UnfilledOrder,
 )

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/backtest/pricing.py

@@ -31,9 +31,8 @@ import pandas as pd
 
 from ..data.fetcher import DataFetcher
 from ..exceptions import CalculationError
-from ..index.result import IndexResult
+from ..index.result import IndexResult, PriceGap
 from ..index.schedule import is_session
-from .result import PriceGap
 
 logger = logging.getLogger(__name__)
 

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/backtest/result.py

@@ -47,7 +47,7 @@ import pandas as pd
 
 from ..analysis.relative import RelativeMetrics, relative_metrics
 from ..data.fetcher import DataFetcher
-from ..index.result import IndexResult
+from ..index.result import IndexResult, PriceGap
 from ..plot.base import PlotAccessor
 from ..portfolio.base import Portfolio
 from .asset_view import BacktestAssetView
@@ -78,36 +78,8 @@ class UnfilledOrder:
     shortfall_value: float
 
 
-# PriceGap and RebalancePricing are BN-183.
-@dataclass(frozen=True)
-class PriceGap:
-    """A day a name should have traded on and had no bar.
-
-    The engine prices from the last session on or before the date it is
-    marking. Two different things can put it there, and only one of them is a
-    fault: a day the index's **calendar says was closed** is a market that was
-    shut, and the previous session's price is what the position was genuinely
-    worth through it, so no gap is recorded, because nothing is missing. A day
-    the calendar says was **open** is data that is missing something, and the
-    price carried forward is a stale quote.
-
-    Carrying it forward is standard practice and beats refusing: a backtest
-    over five hundred names must not die because one of them had one bad day.
-    Doing it silently is not: the mark is not what that day's market said, so
-    it is published here rather than absorbed, the way `unfilled` publishes the
-    legs a rebalance could not fill.
-
-    Attributes:
-        date: The simulated day whose bar was missing.
-        asset_id: The name with no bar.
-        priced_from: The session the carried price actually came from, always
-            earlier than *date*.
-    """
-    date: pd.Timestamp
-    asset_id: str
-    priced_from: pd.Timestamp
-
-
+# RebalancePricing is BN-183. PriceGap, also BN-183, moved to the index
+# layer with BN-251, when the index started recording gaps too.
 @dataclass(frozen=True)
 class RebalancePricing:
     """What one rebalance priced from.
@@ -369,6 +341,25 @@ class BacktestResult:
 
         return returns.dropna()
 
+    def get_annual_returns(self) -> pd.Series:
+        """The portfolio's calendar-year returns.
+
+        Each year runs from the previous year's last close, and the first from
+        the initial capital, so the years compound to the whole run's return.
+        A partial first or last year covers only its days.
+
+        Returns:
+            pd.Series: Return by calendar year, indexed by the year as an int.
+        """
+        returns = self.get_returns()
+
+        if returns.empty:
+            return pd.Series(dtype=float)
+
+        yearly = (1.0 + returns).groupby(returns.index.year).prod() - 1.0
+
+        return yearly.astype(float)
+
     def get_tracking_error(self) -> float | None:
         """Calculate annualised tracking error against the tracked index.
 

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/backtest/rules.py

@@ -14,6 +14,7 @@ import pandas as pd
 from ..data.fetcher import DataFetcher
 from ..expressions.core import Expression
 from ..expressions.resolve import resolve
+from ..expressions.validation import require_valid
 from ..portfolio.base import Portfolio, TradeInstruction
 
 logger = logging.getLogger(__name__)
@@ -147,12 +148,18 @@ class ExpressionScreen(BacktestModifier):
         fetcher: Data to resolve against.
         on_missing: Whether a name with no value passes. Excluded by default,
             matching the index rules.
+
+    Raises:
+        ExpressionError: If the expression names a field the data does not
+            have.
     """
 
     def __init__(self,
                  expression: "Expression",
                  fetcher: "DataFetcher",
                  on_missing: bool = False):
+        require_valid(expression, fetcher, "ExpressionScreen")
+
         self.expression = expression
         self.fetcher = fetcher
         self.on_missing = on_missing

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/changelog.py

@@ -17,7 +17,7 @@ the emphasis and code spans in them survive to whatever renders them.
 # BN-222. `CHANGELOG.md` at the repository root is the one file anybody
 # edits; the wheel's copy comes from `force-include` in pyproject.toml.
 import re
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from importlib import resources
 from pathlib import Path
 
@@ -43,21 +43,25 @@ class ChangelogSection:
 class ChangelogEntry:
     """One release: its version, its date, and what changed in it.
 
-    `date` is None for the Unreleased entry, which has none.
+    `date` is None for the Unreleased entry, which has none. `summary` is the
+    prose between the release heading and its first section, its lines
+    joined with spaces, or None when there is none.
     """
     version: str
     date: str | None
     sections: list[ChangelogSection] = field(default_factory=list)
+    summary: str | None = None
 
 
 def parse(text: str) -> list[ChangelogEntry]:
     """Read a Keep a Changelog document into entries, newest first.
 
-    Prose between a release heading and its first section (a note that
-    nothing has been released yet, say) is not an item and is skipped. A
-    list item that wraps onto indented lines is joined back into one string.
+    Prose between a release heading and its first section is the entry's
+    summary, not an item. A list item that wraps onto indented lines is
+    joined back into one string.
     """
     entries: list[ChangelogEntry] = []
+    prose: list[list[str]] = []
     section: ChangelogSection | None = None
 
     for line in text.splitlines():
@@ -66,6 +70,7 @@ def parse(text: str) -> list[ChangelogEntry]:
         if release is not None:
             entries.append(ChangelogEntry(version=release["version"],
                                           date=release["date"]))
+            prose.append([])
             section = None
             continue
 
@@ -79,9 +84,15 @@ def parse(text: str) -> list[ChangelogEntry]:
             entries[-1].sections.append(section)
             continue
 
+        # BN-274: the summary used to be skipped.
+        if section is None and line.strip():
+            prose[-1].append(line.strip())
+            continue
+
         section = _add_line(section, line)
 
-    return entries
+    return [replace(entry, summary=" ".join(lines) or None)
+            for entry, lines in zip(entries, prose, strict=True)]
 
 
 def _add_line(section: ChangelogSection | None,

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/data/__init__.py

@@ -25,7 +25,7 @@ __all__ = [
 # anybody who guessed the other import at the right one. Without it the error
 # is "module 'beacon.data' has no attribute 'market'", which is true and tells
 # nobody what to do about it.
-_EXPRESSION_ROOTS = ("market", "reference", "actions")
+_EXPRESSION_ROOTS = ("market", "reference")
 
 
 def __getattr__(name: str) -> Any:

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/data/adjustment.py

@@ -47,7 +47,7 @@ import logging
 import numpy as np
 import pandas as pd
 
-from .corporate_actions import CASH_ACTIONS, RATIO_ACTIONS
+from .corporate_actions import CASH_ACTIONS, RATIO_ACTIONS, without_cancelled
 
 logger = logging.getLogger(__name__)
 
@@ -90,7 +90,7 @@ def _factors(closes: pd.Series,
     if actions is None or actions.empty:
         return factors
 
-    for _, action in actions.iterrows():
+    for _, action in without_cancelled(actions).iterrows():
         ex_date = pd.Timestamp(action["EX_DATE"])
         action_type = str(action["TYPE"])
 

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/data/corporate_actions.py

@@ -123,6 +123,22 @@ def kind_of(action_type: str) -> Kind:
     return STRUCTURAL
 
 
+def without_cancelled(actions: pd.DataFrame) -> pd.DataFrame:
+    """*actions* less any whose status is cancelled.
+
+    A cancelled action never happened, so nothing that applies actions (a
+    split to units held, a dividend to a total return, either to an adjusted
+    close) or sums them (a trailing dividend) may count it. Rows with no
+    status, or a frame with no status column, are kept.
+    """
+    # BN-261: the ratio schedule already did this; the dividend readers and
+    # the adjusted closes did not.
+    if actions.empty or STATUS_COLUMN not in actions.columns:
+        return actions
+
+    return actions[actions[STATUS_COLUMN].map(status_of) != CANCELLED]
+
+
 def status_of(value: object) -> Status | None:
     """Normalise a stored status, or None if it is not one this vocabulary has.
 
@@ -372,7 +388,7 @@ class CorporateActions:
         end = pd.Timestamp(as_of)
         start = end - TRAILING_YEAR
 
-        subset = self.get(identifier, types=types)
+        subset = without_cancelled(self.get(identifier, types=types))
         if subset.empty:
             return subset
 
@@ -434,10 +450,7 @@ class CorporateActions:
                 multiplier would erase or invert a position.
         """
         frame = self._df
-        ratios = frame[frame["TYPE"].isin(RATIO_ACTIONS)]
-
-        if STATUS_COLUMN in ratios.columns:
-            ratios = ratios[ratios[STATUS_COLUMN].map(status_of) != CANCELLED]
+        ratios = without_cancelled(frame[frame["TYPE"].isin(RATIO_ACTIONS)])
 
         schedule: dict[pd.Timestamp, dict[str, float]] = {}
 

{py_beacon_kit-0.2.0 → py_beacon_kit-0.3.0}/src/beacon/data/fetcher.py

@@ -21,6 +21,7 @@ from .free_float import (
     carried_forward,
     validated_window,
 )
+from .prices import prices_in
 from .session import SessionPanel
 
 logger = logging.getLogger(__name__)
@@ -269,6 +270,8 @@ class DataFetcher:
         self._fx_series: dict[tuple[str, str], pd.Series] = {}
         # How each cached pair was found: direct, inverse, or a cross (BN-235).
         self._fx_routes: dict[tuple[str, str], str | None] = {}
+        # Pairs already warned about being stored without RATE (BN-226).
+        self._unlisted_pairs: set[str] = set()
         # Each name's observed free floats, blanks dropped, read once when a
         # blank day first needs carrying over (BN-219). Cleared with the FX
         # series on a merge, for the same reason.
@@ -968,6 +971,26 @@ class DataFetcher:
         val = df[column].iloc[0]
         return float(val) if pd.notna(val) else None
 
+    def fetch_prices(self,
+                     identifiers: list[str],
+                     start_date: str | None = None,
+                     end_date: str | None = None,
+                     currency: str | None = None,
+                     column: str = "CLOSE") -> pd.DataFrame:
+        """Prices by date and instrument, converted into *currency*.
+
+        The read to use whenever prices of several instruments are compared
+        or added up: each is converted from its own currency day by day under
+        this fetcher's FX policy. With ``currency=None`` nothing is converted.
+        See `beacon.data.prices`.
+
+        Raises:
+            CalculationError: If an instrument's currency has no rate into
+                *currency*.
+        """
+        return prices_in(self, identifiers, start_date, end_date, currency,
+                         column)
+
     def fetch_fx_rates(self,
                        from_currency: str,
                        to_currency: str,
@@ -977,10 +1000,12 @@ class DataFetcher:
         """Return the stored FX rate series converting *from_currency* into *to_currency*.
 
         The pair is looked up as a market-data identifier named
-        ``f"{from_currency}{to_currency}"`` (upper-cased). The *column* field is
-        used if present, otherwise the first data column. Returns an empty
-        Series if that exact pair is not stored: this does not invert or cross
-        rates. :meth:`fx_rate_on` and :meth:`fx_rates_on` do.
+        ``f"{from_currency}{to_currency}"`` (upper-cased), and its *column*
+        read. A pair should carry `RATE`, which is also what :attr:`fx_pairs`
+        lists pairs by. One stored without it is read from its first data
+        column, with a warning, and is not listed. Returns an empty Series if
+        that exact pair is not stored: this does not invert or cross rates.
+        :meth:`fx_rate_on` and :meth:`fx_rates_on` do.
         """
         pair = f"{from_currency}{to_currency}".upper()
         if pair not in self._market.identifiers:
@@ -988,8 +1013,20 @@ class DataFetcher:
         df = self._market.get(pair, start_date, end_date)
         if df.empty:
             return pd.Series(dtype=float)
-        rate_col = column if column in df.columns else df.columns[0]
-        return df[rate_col]
+
+        if column in df.columns and df[column].notna().any():
+            return df[column]
+
+        # BN-226: kept for stores written without RATE, but said, because
+        # such a pair converts and `fx_pairs` does not list it.
+        fallback = next(name for name in df.columns if name != column)
+        if pair not in self._unlisted_pairs:
+            self._unlisted_pairs.add(pair)
+            logger.warning("%s has no %s values, so it is read from %s and "
+                           "is not listed among the currency pairs. Store its "
+                           "rate in %s.", pair, column, fallback, column)
+
+        return df[fallback]
 
     def fx_route(self,
                  from_currency: str,