fix(currency): show auto currency on table charts

Author: richardfogaca

superset-frontend/package-lock.json

@@ -33,7 +33,11 @@
     get_column_name,
     get_time_filter_status,
 )
-from superset.utils.currency import detect_currency, detect_currency_from_df
+from superset.utils.currency import (
+    detect_currency,
+    detect_currency_from_df,
+    has_auto_currency_in_column_config,
+)
 
 if TYPE_CHECKING:
     from superset.common.query_context import QueryContext
@@ -105,18 +109,28 @@ def _detect_currency(
     First attempts to detect from the provided dataframe if the currency
     column is present. Falls back to a separate query only when needed.
 
+    Checks both top-level currency_format (used by Pie, Timeseries, etc.)
+    and column_config (used by Table charts) for AUTO currency settings.
+
     :param query_context: The query context with form_data containing currency_format
     :param query_obj: The original query object with filters
     :param datasource: The datasource being queried
     :param df: Optional dataframe to detect currency from (avoids extra query)
     :return: ISO 4217 currency code (e.g., "USD") or None
     """
-    # Only detect if currency_format.symbol is AUTO
     form_data = query_context.form_data or {}
+
+    # Check top-level currency_format (for Pie, Timeseries, etc.)
     currency_format = form_data.get("currency_format", {})
-    if not isinstance(currency_format, dict):
-        return None
-    if currency_format.get("symbol") != "AUTO":
+    top_level_auto = (
+        isinstance(currency_format, dict) and currency_format.get("symbol") == "AUTO"
+    )
+
+    # Check column_config (for Table charts)
+    column_config_auto = has_auto_currency_in_column_config(form_data)
+
+    # Only detect if AUTO is configured somewhere
+    if not top_level_auto and not column_config_auto:
         return None
 
     currency_column = getattr(datasource, "currency_code_column", None)

superset/common/query_actions.py

@@ -30,6 +30,7 @@
 from superset.models.slice import Slice
 from superset.superset_typing import Column
 from superset.utils.core import DatasourceDict, DatasourceType, is_adhoc_column
+from superset.utils.currency import has_auto_currency_in_column_config
 
 # Charts supporting per-cell currency detection
 CELL_LEVEL_CURRENCY_VIZ_TYPES = {"pivot_table_v2", "table"}
@@ -213,6 +214,9 @@ def _add_currency_column(
         queries (like pivot tables) to include currency codes per row,
         allowing per-cell currency formatting based on the data.
 
+        Checks both top-level currency_format (used by Pie, Timeseries, etc.)
+        and column_config (used by Table charts) for AUTO currency settings.
+
         Only applies to viz types that support cell-level detection (e.g., pivot tables)
         Other charts like pie charts use the dataset-level detected_currency instead.
         """
@@ -224,8 +228,18 @@ def _add_currency_column(
         if viz_type not in CELL_LEVEL_CURRENCY_VIZ_TYPES:
             return
 
+        # Check top-level currency_format (for Pie, Timeseries, etc.)
         currency_format = form_data.get("currency_format", {})
-        if currency_format.get("symbol") != "AUTO":
+        top_level_auto = (
+            isinstance(currency_format, dict)
+            and currency_format.get("symbol") == "AUTO"
+        )
+
+        # Check column_config (for Table charts)
+        column_config_auto = has_auto_currency_in_column_config(form_data)
+
+        # Only inject if AUTO is configured somewhere
+        if not top_level_auto and not column_config_auto:
             return
 
         currency_column = getattr(datasource, "currency_code_column", None)

superset/common/query_context_factory.py

@@ -32,6 +32,33 @@
 logger = logging.getLogger(__name__)
 
 
+def has_auto_currency_in_column_config(form_data: dict[str, Any] | None) -> bool:
+    """
+    Check if any column in column_config has AUTO currency format.
+
+    Used by Table charts which configure currency per-column via column_config,
+    rather than using top-level currency_format like other chart types.
+
+    :param form_data: The form data containing column_config
+    :return: True if any column has AUTO currency format
+    """
+    if not form_data:
+        return False
+    column_config = form_data.get("column_config", {})
+    if not isinstance(column_config, dict):
+        return False
+    for config in column_config.values():
+        if not isinstance(config, dict):
+            continue
+        currency_format = config.get("currencyFormat", {})
+        if (
+            isinstance(currency_format, dict)
+            and currency_format.get("symbol") == "AUTO"
+        ):
+            return True
+    return False
+
+
 def detect_currency_from_df(
     df: Any,  # pd.DataFrame, but avoiding import for type checking
     currency_column: str,

superset/utils/currency.py

@@ -77,7 +77,11 @@
     merge_extra_filters,
     simple_filter_to_adhoc,
 )
-from superset.utils.currency import detect_currency, detect_currency_from_df
+from superset.utils.currency import (
+    detect_currency,
+    detect_currency_from_df,
+    has_auto_currency_in_column_config,
+)
 from superset.utils.date_parser import get_since_until, parse_past_timedelta
 from superset.utils.hashing import hash_from_str
 
@@ -488,15 +492,25 @@ def _detect_currency(
         First attempts to detect from the provided dataframe if the currency
         column is present. Falls back to a separate query only when needed.
 
+        Checks both top-level currency_format (used by Pie, Timeseries, etc.)
+        and column_config (used by Table charts) for AUTO currency settings.
+
         :param query_obj: The query object with filters
         :param df: Optional dataframe to detect currency from (avoids extra query)
         :return: ISO 4217 currency code (e.g., "USD") or None
         """
-        # Only detect if currency_format.symbol is AUTO
+        # Check top-level currency_format (for Pie, Timeseries, etc.)
         currency_format = self.form_data.get("currency_format", {})
-        if not isinstance(currency_format, dict):
-            return None
-        if currency_format.get("symbol") != "AUTO":
+        top_level_auto = (
+            isinstance(currency_format, dict)
+            and currency_format.get("symbol") == "AUTO"
+        )
+
+        # Check column_config (for Table charts)
+        column_config_auto = has_auto_currency_in_column_config(self.form_data)
+
+        # Only detect if AUTO is configured somewhere
+        if not top_level_auto and not column_config_auto:
             return None
 
         currency_column = getattr(self.datasource, "currency_code_column", None)

superset/viz.py

@@ -14,12 +14,14 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+from typing import Any
 from unittest.mock import MagicMock, patch
 
 import pandas as pd
 import pytest
 
 from superset.common.query_actions import _detect_currency
+from superset.viz import BaseViz
 
 
 @pytest.fixture
@@ -50,6 +52,24 @@ def mock_datasource() -> MagicMock:
     return ds
 
 
+@pytest.fixture
+def base_query_obj() -> dict[str, Any]:
+    return {
+        "filter": [],
+        "granularity": None,
+        "from_dttm": None,
+        "to_dttm": None,
+        "extras": {},
+    }
+
+
+def _build_viz(form_data: dict[str, Any], datasource: MagicMock) -> BaseViz:
+    viz = BaseViz.__new__(BaseViz)
+    viz.form_data = form_data
+    viz.datasource = datasource
+    return viz
+
+
 def test_detect_currency_returns_none_when_form_data_is_none(
     mock_query_obj: MagicMock,
     mock_datasource: MagicMock,
@@ -157,3 +177,174 @@ def test_detect_currency_queries_datasource_when_column_not_in_df(
 
     assert result == "GBP"
     mock_detect.assert_called_once()
+
+
+# Tests for column_config AUTO detection (Table charts)
+
+
+@pytest.fixture
+def mock_query_context_with_column_config() -> MagicMock:
+    """Create a mock QueryContext with column_config AUTO currency (Table charts)."""
+    context = MagicMock()
+    context.form_data = {
+        "column_config": {
+            "cost": {"currencyFormat": {"symbol": "AUTO", "symbolPosition": "prefix"}}
+        }
+    }
+    return context
+
+
+@patch("superset.common.query_actions.detect_currency")
+def test_detect_currency_checks_column_config_for_auto(
+    mock_detect: MagicMock,
+    mock_query_context_with_column_config: MagicMock,
+    mock_query_obj: MagicMock,
+    mock_datasource: MagicMock,
+) -> None:
+    """Runs detection when column_config has AUTO currency (Table charts)."""
+    mock_detect.return_value = "USD"
+
+    result = _detect_currency(
+        mock_query_context_with_column_config,
+        mock_query_obj,
+        mock_datasource,
+    )
+
+    assert result == "USD"
+    mock_detect.assert_called_once()
+
+
+@patch("superset.common.query_actions.detect_currency_from_df")
+def test_detect_currency_column_config_uses_dataframe(
+    mock_detect_from_df: MagicMock,
+    mock_query_context_with_column_config: MagicMock,
+    mock_query_obj: MagicMock,
+    mock_datasource: MagicMock,
+) -> None:
+    """Uses dataframe detection when column_config has AUTO and df has currency."""
+    df = pd.DataFrame({"currency_code": ["EUR", "EUR"]})
+    mock_detect_from_df.return_value = "EUR"
+
+    result = _detect_currency(
+        mock_query_context_with_column_config,
+        mock_query_obj,
+        mock_datasource,
+        df,
+    )
+
+    assert result == "EUR"
+    mock_detect_from_df.assert_called_once_with(df, "currency_code")
+
+
+def test_detect_currency_skips_when_no_auto_in_column_config(
+    mock_query_obj: MagicMock,
+    mock_datasource: MagicMock,
+) -> None:
+    """Returns None when column_config has explicit currency (not AUTO)."""
+    context = MagicMock()
+    context.form_data = {
+        "column_config": {"cost": {"currencyFormat": {"symbol": "USD"}}}
+    }
+
+    result = _detect_currency(context, mock_query_obj, mock_datasource)
+
+    assert result is None
+
+
+@patch("superset.common.query_actions.detect_currency")
+def test_detect_currency_works_with_both_top_level_and_column_config(
+    mock_detect: MagicMock,
+    mock_query_obj: MagicMock,
+    mock_datasource: MagicMock,
+) -> None:
+    """Detects when both top-level and column_config have AUTO."""
+    context = MagicMock()
+    context.form_data = {
+        "currency_format": {"symbol": "AUTO"},
+        "column_config": {"cost": {"currencyFormat": {"symbol": "AUTO"}}},
+    }
+    mock_detect.return_value = "JPY"
+
+    result = _detect_currency(context, mock_query_obj, mock_datasource)
+
+    assert result == "JPY"
+    mock_detect.assert_called_once()
+
+
+@patch("superset.common.query_actions.detect_currency")
+def test_detect_currency_top_level_auto_triggers_detection(
+    mock_detect: MagicMock,
+    mock_query_obj: MagicMock,
+    mock_datasource: MagicMock,
+) -> None:
+    """Detects when only top-level currency_format has AUTO."""
+    context = MagicMock()
+    context.form_data = {
+        "currency_format": {"symbol": "AUTO"},
+        "column_config": {
+            "cost": {"currencyFormat": {"symbol": "USD"}}  # explicit, not AUTO
+        },
+    }
+    mock_detect.return_value = "CAD"
+
+    result = _detect_currency(context, mock_query_obj, mock_datasource)
+
+    assert result == "CAD"
+    mock_detect.assert_called_once()
+
+
+def test_detect_currency_column_config_no_currency_column_returns_none(
+    mock_query_context_with_column_config: MagicMock,
+    mock_query_obj: MagicMock,
+) -> None:
+    """Returns None when column_config has AUTO but datasource lacks currency column."""
+    datasource = MagicMock()
+    datasource.currency_code_column = None
+
+    result = _detect_currency(
+        mock_query_context_with_column_config,
+        mock_query_obj,
+        datasource,
+    )
+
+    assert result is None
+
+
+@patch("superset.viz.detect_currency")
+def test_viz_detect_currency_checks_column_config_for_auto(
+    mock_detect: MagicMock,
+    base_query_obj: dict[str, Any],
+    mock_datasource: MagicMock,
+) -> None:
+    """Runs detection when column_config has AUTO currency (legacy API)."""
+    mock_detect.return_value = "USD"
+    form_data = {"column_config": {"cost": {"currencyFormat": {"symbol": "AUTO"}}}}
+    viz = _build_viz(form_data, mock_datasource)
+
+    result = BaseViz._detect_currency(viz, base_query_obj)
+
+    assert result == "USD"
+    mock_detect.assert_called_once_with(
+        datasource=mock_datasource,
+        filters=base_query_obj["filter"],
+        granularity=base_query_obj["granularity"],
+        from_dttm=base_query_obj["from_dttm"],
+        to_dttm=base_query_obj["to_dttm"],
+        extras=base_query_obj["extras"],
+    )
+
+
+@patch("superset.viz.detect_currency")
+def test_viz_detect_currency_skips_without_auto_in_column_config(
+    mock_detect: MagicMock,
+    base_query_obj: dict[str, Any],
+    mock_datasource: MagicMock,
+) -> None:
+    """Returns None when column_config has explicit currency (legacy API)."""
+    form_data = {"column_config": {"cost": {"currencyFormat": {"symbol": "USD"}}}}
+    viz = _build_viz(form_data, mock_datasource)
+
+    result = BaseViz._detect_currency(viz, base_query_obj)
+
+    assert result is None
+    mock_detect.assert_not_called()