FEAT: re-activate sort for hlabels

* also implemented sort on DirectoryPath, Polars DF and LF and Narwhals LF
* reset sort when changing the filter. There are cases where we could keep it but this will have to wait later

Author: gdementen

larray_editor/arrayadapter.py

@@ -970,38 +970,66 @@ def __init__(self, data, attributes):
         path_objs = list(data.iterdir())
         # sort by type then name
         path_objs.sort(key=lambda p: (not p.is_dir(), p.name))
+
         parent_dir = data.parent
         if parent_dir != data:
             path_objs.insert(0, parent_dir)
-        self._path_objs = path_objs
+        self._sorted_path_objs = path_objs
+
+        self._colnames = ['Name', 'Time Modified', 'Size']
 
+    def shape2d(self):
+        return len(self._sorted_path_objs), len(self._colnames)
+
+    def get_hlabels_values(self, start, stop):
+        return [self._colnames[start:stop]]
+
+    def get_values(self, h_start, v_start, h_stop, v_stop):
         def file_mtime_as_str(p) -> str:
             try:
                 mt_time = datetime.fromtimestamp(p.stat().st_mtime)
                 return mt_time.strftime('%d/%m/%Y %H:%M')
             except Exception:
                 return ''
-
-        self._list = [(
+        parent_dir = self.data.parent
+        return [(
             p.name if p != parent_dir else '..',
             # give the mtime of the "current" directory
-           file_mtime_as_str(p if p != parent_dir else data),
-           '<directory>' if p.is_dir() else p.stat().st_size
-        ) for p in path_objs]
-        self._colnames = ['Name', 'Time Modified', 'Size']
+            file_mtime_as_str(p if p != parent_dir else self.data),
+            '<directory>' if p.is_dir() else p.stat().st_size
+        )[h_start:h_stop] for p in self._sorted_path_objs[v_start:v_stop]]
 
-    def shape2d(self):
-        return len(self._list), len(self._colnames)
+    def can_sort_hlabel(self, row_idx, col_idx):
+        return True
 
-    def get_hlabels_values(self, start, stop):
-        return [self._colnames[start:stop]]
+    def sort_hlabel(self, row_idx, col_idx, ascending):
+        assert row_idx == 0
+        assert col_idx in {0, 1, 2}
+        self._current_sort = [(self.num_v_axes() + row_idx, col_idx, ascending)]
+        # strip ".." before sorting
+        path_objs = self._sorted_path_objs[1:]
+
+        def get_sort_key(p):
+            # name
+            if col_idx == 0:
+                return not p.is_dir(), p.name
+            # time
+            elif col_idx == 1:
+                return not p.is_dir(), p.stat().st_mtime
+            # size
+            else:
+                return not p.is_dir(), p.stat().st_size
 
-    def get_values(self, h_start, v_start, h_stop, v_stop):
-        return [row[h_start:h_stop]
-                for row in self._list[v_start:v_stop]]
+        path_objs.sort(key=get_sort_key, reverse=not ascending)
+
+        # re-add ".."
+        parent_dir = self.data.parent
+        if parent_dir != self.data:
+            path_objs.insert(0, parent_dir)
+        self._sorted_path_objs = path_objs
 
     def cell_activated(self, row_idx, column_idx):
-        return self._path_objs[row_idx].absolute()
+        return self._sorted_path_objs[row_idx].absolute()
 
 
 @adapter_for('pathlib.Path')
@@ -2096,6 +2124,10 @@ def get_values(self, h_start, v_start, h_stop, v_stop):
 @adapter_for('polars.DataFrame')
 @adapter_for('narwhals.DataFrame')
 class PolarsDataFrameAdapter(AbstractColumnarAdapter):
+    def __init__(self, data, attributes):
+        super().__init__(data, attributes=attributes)
+        self.sorted_data = data
+
     def shape2d(self):
         return self.data.shape
 
@@ -2107,7 +2139,15 @@ def get_values(self, h_start, v_start, h_stop, v_stop):
         # has a better behavior for datetime columns (e.g. pl_df3).
         # Otherwise, Polars converts datetimes to floats instead using a numpy
         # object array
-        return self.data[v_start:v_stop, h_start:h_stop].to_pandas().values
+        return self.sorted_data[v_start:v_stop, h_start:h_stop].to_pandas().values
+
+    def can_sort_hlabel(self, row_idx, col_idx):
+        return True
+
+    def sort_hlabel(self, row_idx, col_idx, ascending):
+        self._current_sort = [(self.num_v_axes() + row_idx, col_idx, ascending)]
+        self.sorted_data = self.data.sort(self.data.columns[col_idx],
+                                          descending=not ascending)
 
 
 @adapter_for('polars.LazyFrame')
@@ -2123,6 +2163,7 @@ def __init__(self, data, attributes):
         #       so we could try to use a temporary value and
         #       fill the real height as we go like for CSV files
         self._height = data.select(pl.len()).collect(engine='streaming').item()
+        self.sorted_data = data
 
     def shape2d(self):
         return self._height, len(self._schema)
@@ -2131,14 +2172,23 @@ def get_hlabels_values(self, start, stop):
         return [self._columns[start:stop]]
 
     def get_values(self, h_start, v_start, h_stop, v_stop):
-        subset = self.data[v_start:v_stop].select(self._columns[h_start:h_stop])
+        lf = self.sorted_data
+        subset = lf[v_start:v_stop].select(self._columns[h_start:h_stop])
         df = subset.collect(engine='streaming')
         # Going via Pandas instead of directly using to_numpy() because this
         # has a better behavior for datetime columns (e.g. pl_df3).
         # Otherwise, Polars converts datetimes to floats instead using a numpy
         # object array
         return df.to_pandas().values
 
+    def can_sort_hlabel(self, row_idx, col_idx):
+        return True
+
+    def sort_hlabel(self, row_idx, col_idx, ascending):
+        self._current_sort = [(self.num_v_axes() + row_idx, col_idx, ascending)]
+        self.sorted_data = self.data.sort(self._columns[col_idx],
+                                          descending=not ascending)
+
 
 @adapter_for('narwhals.LazyFrame')
 class NarwhalsLazyFrameAdapter(AbstractColumnarAdapter):
@@ -2157,6 +2207,7 @@ def __init__(self, data, attributes):
         #       Polars but probably not other engines)
         self._height = data.select(nw.len()).collect(engine='streaming').item()
         self._wh_index = data.with_row_index('_index')
+        self.sorted_data = data
 
     def shape2d(self):
         return self._height, len(self._schema)
@@ -2174,6 +2225,14 @@ def get_values(self, h_start, v_start, h_stop, v_stop):
         lazy_sub_df = self._wh_index.filter(filter_).select(self._columns[h_start:h_stop])
         return lazy_sub_df.collect(engine='streaming').to_numpy()
 
+    def can_sort_hlabel(self, row_idx, col_idx):
+        return True
+
+    def sort_hlabel(self, row_idx, col_idx, ascending):
+        self._current_sort = [(self.num_v_axes() + row_idx, col_idx, ascending)]
+        self.sorted_data = self.data.sort(self._columns[col_idx],
+                                          descending=not ascending)
+
 
 @adapter_for('iode.Variables')
 class IodeVariablesAdapter(AbstractAdapter):

larray_editor/arraywidget.py

@@ -171,6 +171,7 @@ def change_filter(self, filter_idx, filter_name, indices):
         old_h_pos = hscrollbar.value()
         old_nrows, old_ncols = data_adapter.shape2d()
         data_adapter.update_filter(filter_idx, filter_name, indices)
+        data_adapter._current_sort = []
         # TODO: this does too much work (it sets the adapters even
         #       if those do not change and sets v_offset/h_offset to 0 when we
         #       do not *always* want to do so) and maybe too little
@@ -186,10 +187,8 @@ def change_filter(self, filter_idx, filter_name, indices):
             # if the old values were already 0, visible_v/hscroll_changed will
             # not be triggered and update_*_column_widths has no chance to run
             # unless we call them explicitly
-            array_widget._update_axes_column_widths_from_content()
-            array_widget._update_hlabels_column_widths_from_content()
-            array_widget._update_axes_row_heights_from_content()
-            array_widget._update_vlabels_row_heights_from_content()
+            assert isinstance(array_widget, ArrayEditorWidget)
+            array_widget.update_cell_sizes_from_content()
         else:
             # TODO: would be nice to implement some clever positioning algorithm
             #       here when new_X != old_X so that the visible rows stay visible.
@@ -765,7 +764,8 @@ def __init__(self, parent, model, hpos, vpos):
         AbstractView.__init__(self, parent, model, hpos, vpos)
 
         # FIXME: only have this if the adapter supports any extra action on axes
-        # self.clicked.connect(self.on_clicked)
+        if self.vpos == TOP:
+            self.clicked.connect(self.on_clicked)
 
     def on_clicked(self, index: QModelIndex):
         if not index.isValid():
@@ -774,6 +774,8 @@ def on_clicked(self, index: QModelIndex):
         row_idx = index.row()
         column_idx = index.column()
 
+        assert self.vpos == TOP
+
         # FIXME: column_idx works fine for the unfiltered/initial array but on
         #        an already filtered array it breaks because column_idx is the
         #        idx of the *filtered* array which can contain less axes while
@@ -782,11 +784,7 @@ def on_clicked(self, index: QModelIndex):
         # try:
         adapter = self.model().adapter
         filtrable = adapter.can_filter_hlabel(1, column_idx)
-        # hlabels
-        if self.vpos == TOP:
-            sortable = adapter.can_sort_hlabel(row_idx, column_idx)
-        else:
-            sortable = False
+        sortable = adapter.can_sort_hlabel(row_idx, column_idx)
         if sortable:
             sort_direction = adapter.hlabel_sort_direction(row_idx, column_idx)
             print(f"LabelsView.on_clicked sortable {sort_direction}")
@@ -1709,8 +1707,9 @@ def update_cell_sizes_from_content(self):
         self._update_hlabels_column_widths_from_content()
         # we do not need to update axes cell size on scroll but vlabels
         # width can change on scroll (and they are linked to axes widths)
-        self._update_axes_column_widths_from_content()
         self._update_vlabels_row_heights_from_content()
+        self._update_axes_column_widths_from_content()
+        self._update_axes_row_heights_from_content()
 
     def visible_hscroll_changed(self, value):
         # 'value' will be the first visible column
@@ -2278,6 +2277,9 @@ def sort_axis_labels(self, axis_idx, ascending):
     def sort_hlabel(self, row_idx, col_idx, ascending):
         self.data_adapter.sort_hlabel(row_idx, col_idx, ascending)
         self._set_models_adapter()
+        # since we will probably display different rows, they can have different
+        # column widths
+        self.update_cell_sizes_from_content()
 
     def copy(self):
         """Copy selection as text to clipboard"""