fix(fetcher): resolve minor currencies against non-USD bases via inverse pair

Cash positions in less-traded currencies (UAH, in the reported case)
were silently dropping out of every total when the portfolio used a
non-USD base.  Yahoo only publishes the major pairs in one direction
-- ``EURUAH=X`` exists but ``UAHEUR=X`` doesn't -- so a portfolio with
UAH cash and an EUR base couldn't be valued at all for that row,
which rendered as ``N/A`` in the table and made the freshly-added
aggregate footer ``N/A`` too.

Falling back to the inverse ticker when the direct one is missing
recovers the rate for every minor currency Yahoo carries against the
base in either direction, without forcing every user to add USD as
an intermediate hop in their YAML.  The fallback only fires when the
direct pass leaves something unresolved, so the common case still
costs a single yfinance call.

Signed-off-by: Igor Opaniuk <igor.opaniuk@gmail.com>

Author: igoropaniuk

src/stonks_cli/fetcher.py

@@ -378,9 +378,13 @@ def fetch_forex_rates(
     ) -> dict[str, float]:
         """Return exchange rates: 1 unit of currency -> how many base units.
 
-        Uses yfinance forex pairs (e.g. EURUSD=X for EUR->USD).
-        The base currency is always included as 1.0. Currencies for which
-        no rate can be fetched are omitted from the result.
+        Uses yfinance forex pairs (e.g. ``EURUSD=X`` for EUR->USD).  When
+        a direct ``{currency}{base}=X`` ticker isn't published by Yahoo
+        (common for minor / less-traded currencies like ``UAH`` against
+        non-USD bases), the inverse pair ``{base}{currency}=X`` is
+        attempted and the rate reciprocated.  The base currency is
+        always included as 1.0.  Currencies for which neither pair
+        resolves are omitted from the result.
 
         Args:
             currencies: ISO 4217 currency codes (e.g. ['EUR', 'GBP']).
@@ -396,17 +400,39 @@ def fetch_forex_rates(
         if not non_base:
             return rates
 
-        symbols = [f"{c}{base}=X" for c in non_base]
-        close = _yf_download_close(
-            symbols, period="1d", description="forex", auto_adjust=False
+        # First pass: direct ``{c}{base}=X`` pairs.
+        direct_syms = [f"{c}{base}=X" for c in non_base]
+        direct_close = _yf_download_close(
+            direct_syms, period="1d", description="forex", auto_adjust=False
+        )
+        direct = (
+            _last_close_per_symbol(direct_close, direct_syms)
+            if direct_close is not None
+            else {}
         )
-        if close is None:
-            return rates
 
-        last = _last_close_per_symbol(close, symbols)
-        for currency, symbol in zip(non_base, symbols):
-            if symbol in last:
-                rates[currency] = last[symbol]
+        # Second pass: for each currency Yahoo didn't return directly,
+        # try the inverse ``{base}{c}=X`` pair and reciprocate.  Yahoo
+        # publishes ``EURUAH=X`` but not ``UAHEUR=X``, for instance.
+        missing = [c for c in non_base if f"{c}{base}=X" not in direct]
+        inverse: dict[str, float] = {}
+        if missing:
+            inverse_syms = [f"{base}{c}=X" for c in missing]
+            inverse_close = _yf_download_close(
+                inverse_syms, period="1d", description="forex", auto_adjust=False
+            )
+            if inverse_close is not None:
+                inverse = _last_close_per_symbol(inverse_close, inverse_syms)
+
+        for currency in non_base:
+            direct_sym = f"{currency}{base}=X"
+            if direct_sym in direct:
+                rates[currency] = direct[direct_sym]
+                continue
+            inverse_sym = f"{base}{currency}=X"
+            inv_rate = inverse.get(inverse_sym)
+            if inv_rate and inv_rate != 0:
+                rates[currency] = 1.0 / inv_rate
         return rates
 
     def fetch_stock_detail(self, symbol: str) -> StockDetail:

tests/test_fetcher.py

@@ -380,12 +380,54 @@ def test_returns_base_only_on_empty_download(self, mock_dl, fetcher: PriceFetche
 
     @patch("stonks_cli.fetcher.yf.download")
     def test_omits_currency_with_no_data(self, mock_dl, fetcher: PriceFetcher):
-        # Only EUR returned, GBP missing from columns
+        # Only EUR returned, GBP missing from columns -- and the inverse
+        # ``USDGBP=X`` lookup also returns nothing, so GBP is dropped.
         mock_dl.return_value = _close_df({"EURUSD=X": 1.085})
         rates = fetcher.fetch_forex_rates(["EUR", "GBP"], base="USD")
         assert "EUR" in rates
         assert "GBP" not in rates
 
+    @patch("stonks_cli.fetcher.yf.download")
+    def test_falls_back_to_inverse_pair_when_direct_missing(
+        self, mock_dl, fetcher: PriceFetcher
+    ):
+        # Regression: UAH had no Yahoo entry for ``UAHEUR=X`` so the rate
+        # silently dropped, rendering ``N/A`` in the portfolio cash row
+        # even though Yahoo did publish the inverse ``EURUAH=X``.  The
+        # fetcher now falls back to the inverse pair and reciprocates.
+        # First call (direct ``{currency}{base}=X``) returns only EUR.
+        # Second call (inverse ``{base}{currency}=X``) returns EURUAH=X.
+        direct = _close_df({"USDEUR=X": 0.86})
+        inverse = _close_df({"EURUAH=X": 51.68})
+        mock_dl.side_effect = [direct, inverse]
+        rates = fetcher.fetch_forex_rates(["USD", "UAH"], base="EUR")
+        assert rates["EUR"] == 1.0
+        assert rates["USD"] == pytest.approx(0.86)
+        # 1 / 51.68 -- 1 UAH in EUR
+        assert rates["UAH"] == pytest.approx(1.0 / 51.68)
+
+    @patch("stonks_cli.fetcher.yf.download")
+    def test_inverse_zero_rate_treated_as_missing(self, mock_dl, fetcher: PriceFetcher):
+        # If Yahoo were to return a bogus zero rate for the inverse pair
+        # we'd divide by zero -- guard against that and drop the
+        # currency rather than emit ``inf``.
+        direct = _close_df({"USDEUR=X": 0.86})
+        inverse = _close_df({"EURUAH=X": 0.0})
+        mock_dl.side_effect = [direct, inverse]
+        rates = fetcher.fetch_forex_rates(["USD", "UAH"], base="EUR")
+        assert "UAH" not in rates
+
+    @patch("stonks_cli.fetcher.yf.download")
+    def test_no_inverse_call_when_all_direct_resolved(
+        self, mock_dl, fetcher: PriceFetcher
+    ):
+        # When every requested currency has a direct pair, the inverse
+        # fallback path should be skipped entirely -- no point paying
+        # for a second yfinance call.
+        mock_dl.return_value = _close_df({"EURUSD=X": 1.085, "GBPUSD=X": 1.27})
+        fetcher.fetch_forex_rates(["EUR", "GBP"], base="USD")
+        assert mock_dl.call_count == 1
+
 
 def _make_ticker(exchange_code: str | None):
     """Return a mock yf.Ticker whose fast_info.exchange is *exchange_code*."""