wip

altair/utils/core.py

@@ -468,27 +468,29 @@ def sanitize_narwhals_dataframe(
     return data.select(columns)
 
 
-def narwhalify(data: DataType) -> nw.DataFrame[Any]:
+def to_eager_narwhals_dataframe(data: DataType) -> nw.DataFrame[Any]:
     """Wrap `data` in `narwhals.DataFrame`.
 
     If `data` is not supported by Narwhals, but it is convertible
     to a PyArrow table, then first convert to a PyArrow Table,
     and then wrap in `narwhals.DataFrame`.
     """
-    if isinstance(data, nw.DataFrame):
-        # Early return if already a Narwhals DataFrame
-        return data
-    # Using `strict=False` will return `data` as-is if the object cannot be converted.
-    data = nw.from_native(data, eager_only=True, strict=False)
-    if isinstance(data, nw.DataFrame):
-        return data
-    if isinstance(data, DataFrameLike):
+    data_nw = nw.from_native(data)
+    if nw.get_level(data_nw) == 'metadata':
+        # If Narwhals' support for `data`'s class is only metadata-level, then we
+        # use the interchange protocol to convert to a PyArrow Table.
         from altair.utils.data import arrow_table_from_dfi_dataframe
-
         pa_table = arrow_table_from_dfi_dataframe(data)
-        return nw.from_native(pa_table, eager_only=True)
-    msg = f"Unsupported data type: {type(data)}"
-    raise TypeError(msg)
+        data_nw = nw.from_native(pa_table, eager_only=True)
+    elif isinstance(data_nw, nw.LazyFrame):
+        msg = (
+            "Lazy objects which do not implement the dataframe interchange protocol "
+            "are not supported. Please collect your lazy object into an eager one "
+            "first."
+        )
+        raise NotImplementedError(msg)
+
+    return data_nw
 
 
 def parse_shorthand(
@@ -636,8 +638,9 @@ def parse_shorthand(
     # if data is specified and type is not, infer type from data
     if "type" not in attrs and is_data_type(data):
         unescaped_field = attrs["field"].replace("\\", "")
-        data_nw = narwhalify(data)
-        if unescaped_field in data_nw.columns:
+        data_nw = nw.from_native(data)
+        schema = data_nw.schema
+        if unescaped_field in schema:
             column = data_nw[unescaped_field]
             if column.dtype in {nw.Object, nw.Unknown} and _is_pandas_dataframe(
                 nw.to_native(data_nw)

altair/utils/data.py

@@ -31,7 +31,6 @@
     sanitize_pandas_dataframe,
     DataFrameLike,
     sanitize_narwhals_dataframe,
-    narwhalify,
 )
 from .core import sanitize_geo_interface
 from .plugin_registry import PluginRegistry
@@ -150,8 +149,8 @@ def raise_max_rows_error():
         else:
             return data
     else:
-        data = narwhalify(data)
-        values = data
+        from altair.utils.core import to_eager_narwhals_dataframe
+        values = to_eager_narwhals_dataframe(data)
 
     if max_rows is not None and len(values) > max_rows:
         raise_max_rows_error()
@@ -196,10 +195,6 @@ def sample(
             # Maybe this should raise an error or return something useful?
             return None
     data = narwhalify(data)
-    if not isinstance(data, nw.DataFrame):
-        # Maybe this should raise an error or return something useful? Currently,
-        # if data is of type SupportsGeoInterface it lands here
-        return None
     if not n:
         if frac is None:
             msg = "frac cannot be None if n is None with this data input type"
@@ -333,13 +328,10 @@ def to_values(data: DataType) -> ToValuesReturnType:
             msg = "values expected in data dict, but not present."
             raise KeyError(msg)
         return data_native
-    elif isinstance(data, nw.DataFrame):
-        data = sanitize_narwhals_dataframe(data)
-        return {"values": data.rows(named=True)}
-    else:
-        # Should never reach this state as tested by check_data_type
-        msg = f"Unrecognized data type: {type(data)}"
-        raise ValueError(msg)
+    from altair.utils.core import to_eager_narwhals_dataframe
+    data = to_eager_narwhals_dataframe(data)
+    data = sanitize_narwhals_dataframe(data)
+    return {"values": data.rows(named=True)}
 
 
 def check_data_type(data: DataType) -> None:

altair/vegalite/v5/api.py

@@ -13,7 +13,6 @@
 from .schema import core, channels, mixins, Undefined, SCHEMA_URL
 
 from altair.utils import Optional
-from altair.utils.data import narwhalify as _narwhalify
 from .data import data_transformers
 from ... import utils
 from ...expr import core as _expr_core
@@ -1016,17 +1015,11 @@ def to_dict(
         # TopLevelMixin instance does not necessarily have copy defined but due to how
         # Altair is set up this should hold. Too complex to type hint right now
         copy = self.copy(deep=False)  # type: ignore[attr-defined]
+        original_data = getattr(copy, "data", Undefined)
+        copy.data = _prepare_data(original_data, context)
 
-        data = getattr(copy, "data", Undefined)
-        try:
-            data = _narwhalify(data)  # type: ignore[arg-type]
-        except TypeError:
-            # Non-narwhalifiable type still supported by Altair, such as dict.
-            pass
-        copy.data = _prepare_data(data, context)
-
-        if data is not Undefined:
-            context["data"] = data
+        if original_data is not Undefined:
+            context["data"] = original_data
 
         # remaining to_dict calls are not at top level
         context["top_level"] = False