refactor: Start transitioning DataFrame.sort to selectors-only

Need to rewrite `ArrowExpr.over_ordered` to make use of the simplification
Maybe something like loop `order_by` and use `meta.as_selector`?

Author: dangotbanned

narwhals/_plan/arrow/dataframe.py

@@ -17,6 +17,7 @@
 from narwhals._plan.compliant.typing import namespace
 from narwhals._plan.expressions import NamedIR
 from narwhals._plan.typing import Seq
+from narwhals._typing_compat import deprecated
 from narwhals._utils import Implementation, Version
 from narwhals.schema import Schema
 
@@ -94,7 +95,14 @@ def _evaluate_irs(self, nodes: Iterable[NamedIR[ExprIR]], /) -> Iterator[Series]
         from_named_ir = ns._expr.from_named_ir
         yield from ns._expr.align(from_named_ir(e, self) for e in nodes)
 
-    def sort(self, by: Seq[NamedIR], options: SortMultipleOptions) -> Self:
+    def sort(self, by: Sequence[str], options: SortMultipleOptions) -> Self:
+        native = self.native
+        indices = pc.sort_indices(native.select(list(by)), options=options.to_arrow(by))
+        return self._with_native(native.take(indices))
+
+    # TODO @dangotbanned: Finish scoping out what breaks if removed
+    @deprecated("Use `DataFrame.sort` instead", category=None)
+    def sort_by_ir(self, by: Seq[NamedIR], options: SortMultipleOptions) -> Self:
         df_by = self.select(by)
         indices = pc.sort_indices(df_by.native, options=options.to_arrow(df_by.columns))
         return self._with_native(self.native.take(indices))

narwhals/_plan/arrow/expr.py

@@ -366,7 +366,7 @@ def over_ordered(
         sort_by = tuple(NamedIR.from_ir(e) for e in node.order_by)
         options = node.sort_options.to_multiple(len(node.order_by))
         idx_name = temp.column_name(frame)
-        sorted_context = frame.with_row_index(idx_name).sort(sort_by, options)
+        sorted_context = frame.with_row_index(idx_name).sort_by_ir(sort_by, options)
         evaluated = node.expr.dispatch(self, sorted_context.drop([idx_name]), name)
         if isinstance(evaluated, ArrowScalar):
             # NOTE: We're already sorted, defer broadcasting to the outer context

narwhals/_plan/compliant/dataframe.py

@@ -64,7 +64,7 @@ def rename(self, mapping: Mapping[str, str]) -> Self: ...
     def schema(self) -> Mapping[str, DType]: ...
     def select(self, irs: Seq[NamedIR]) -> Self: ...
     def select_names(self, *column_names: str) -> Self: ...
-    def sort(self, by: Seq[NamedIR], options: SortMultipleOptions) -> Self: ...
+    def sort(self, by: Sequence[str], options: SortMultipleOptions) -> Self: ...
     def with_columns(self, irs: Seq[NamedIR]) -> Self: ...
 
 

narwhals/_plan/dataframe.py

@@ -105,10 +105,10 @@ def sort(
         descending: OneOrIterable[bool] = False,
         nulls_last: OneOrIterable[bool] = False,
     ) -> Self:
-        sort = _parse.parse_sort_by_into_seq_of_expr_ir(by, *more_by)
+        s_irs = _parse.parse_into_seq_of_selector_ir(by, *more_by)
+        names = expand_selector_irs_names(s_irs, schema=self)
         opts = SortMultipleOptions.parse(descending=descending, nulls_last=nulls_last)
-        named_irs, _ = prepare_projection(sort, schema=self)
-        return self._with_compliant(self._compliant.sort(named_irs, opts))
+        return self._with_compliant(self._compliant.sort(names, opts))
 
     def drop(
         self, *columns: OneOrIterable[ColumnNameOrSelector], strict: bool = True