dataframe-textual 1.9.0__py3-none-any.whl → 1.12.0__py3-none-any.whl

dataframe_textual/data_frame_table.py

@@ -29,11 +29,11 @@ from .common import (
     NULL_DISPLAY,
     RIDX,
     SUBSCRIPT_DIGITS,
+    SUPPORTED_FORMATS,
     DtypeConfig,
     format_row,
     get_next_item,
     parse_placeholders,
-    rindex,
     sleep_async,
     tentative_expr,
     validate_expr,
@@ -412,6 +412,15 @@ class DataFrameTable(DataTable):
         """
         return self.df.item(self.cursor_row_idx, self.cursor_col_idx)
 
+    @property
+    def has_hidden_rows(self) -> bool:
+        """Check if there are any hidden rows.
+
+        Returns:
+            bool: True if there are hidden rows, False otherwise.
+        """
+        return any(v for v in self.visible_rows if v is False)
+
     @property
     def ordered_selected_rows(self) -> list[int]:
         """Get the list of selected row indices in order.
@@ -846,7 +855,12 @@ class DataFrameTable(DataTable):
             cell_str = str(self.df.item(ridx, cidx))
             self.do_copy_to_clipboard(cell_str, f"Copied: [$success]{cell_str[:50]}[/]")
         except IndexError:
-            self.notify("Error copying cell", title="Clipboard", severity="error")
+            self.notify(
+                f"Error copying cell ([$error]{ridx}[/], [$accent]{cidx}[/])",
+                title="Clipboard",
+                severity="error",
+                timeout=10,
+            )
 
     def action_copy_column(self) -> None:
         """Copy the current column to clipboard (one value per line)."""
@@ -862,7 +876,7 @@ class DataFrameTable(DataTable):
                 f"Copied [$accent]{len(col_values)}[/] values from column [$success]{col_name}[/]",
             )
         except (FileNotFoundError, IndexError):
-            self.notify("Error copying column", title="Clipboard", severity="error")
+            self.notify(f"Error copying column [$error]{col_name}[/]", title="Clipboard", severity="error", timeout=10)
 
     def action_copy_row(self) -> None:
         """Copy the current row to clipboard (values separated by tabs)."""
@@ -878,7 +892,7 @@ class DataFrameTable(DataTable):
                 f"Copied row [$accent]{ridx + 1}[/] with [$success]{len(row_values)}[/] values",
             )
         except (FileNotFoundError, IndexError):
-            self.notify("Error copying row", title="Clipboard", severity="error")
+            self.notify(f"Error copying row [$error]{ridx}[/]", title="Clipboard", severity="error", timeout=10)
 
     def action_show_thousand_separator(self) -> None:
         """Toggle thousand separator for numeric display."""
@@ -916,6 +930,27 @@ class DataFrameTable(DataTable):
         self.check_and_load_more()
 
     # Setup & Loading
+    def reset_df(self, new_df: pl.DataFrame, dirty: bool = True) -> None:
+        """Reset the dataframe to a new one and refresh the table.
+
+        Args:
+            new_df: The new Polars DataFrame to set.
+            dirty: Whether to mark the table as dirty (unsaved changes). Defaults to True.
+        """
+        # Set new dataframe and reset table
+        self.df = new_df
+        self.loaded_rows = 0
+        self.sorted_columns = {}
+        self.hidden_columns = set()
+        self.selected_rows = [False] * len(self.df)
+        self.visible_rows = [True] * len(self.df)
+        self.fixed_rows = 0
+        self.fixed_columns = 0
+        self.matches = defaultdict(set)
+        # self.histories.clear()
+        # self.history = None
+        self.dirty = dirty  # Mark as dirty since data changed
+
     def setup_table(self, reset: bool = False) -> None:
         """Setup the table for display.
 
@@ -927,21 +962,10 @@ class DataFrameTable(DataTable):
 
         # Reset to original dataframe
         if reset:
-            self.df = self.dataframe
-            self.loaded_rows = 0
-            self.sorted_columns = {}
-            self.hidden_columns = set()
-            self.selected_rows = [False] * len(self.df)
-            self.visible_rows = [True] * len(self.df)
-            self.fixed_rows = 0
-            self.fixed_columns = 0
-            self.matches = defaultdict(set)
-            self.histories.clear()
-            self.history = None
-            self.dirty = False
+            self.reset_df(self.dataframe, dirty=False)
 
         # Lazy load up to INITIAL_BATCH_SIZE visible rows
-        stop, visible_count = self.INITIAL_BATCH_SIZE, 0
+        stop, visible_count, row_idx = self.INITIAL_BATCH_SIZE, 0, 0
         for row_idx, visible in enumerate(self.visible_rows):
             if not visible:
                 continue
@@ -1175,7 +1199,7 @@ class DataFrameTable(DataTable):
             self.log(f"Loaded {self.loaded_rows}/{len(self.df)} rows from `{self.filename or self.name}`")
 
         except Exception as e:
-            self.notify("Error loading rows", title="Load", severity="error")
+            self.notify("Error loading rows", title="Load", severity="error", timeout=10)
             self.log(f"Error loading rows: {str(e)}")
 
     def check_and_load_more(self) -> None:
@@ -1191,56 +1215,6 @@ class DataFrameTable(DataTable):
         if bottom_visible_row >= self.loaded_rows - 10:
             self.load_rows(self.loaded_rows + self.BATCH_SIZE)
 
-    # Highlighting
-    def apply_highlight(self, force: bool = False) -> None:
-        """Update all rows, highlighting selected ones and restoring others to default.
-
-        Args:
-            force: If True, clear all highlights and restore default styles.
-        """
-        # Ensure all selected rows or matches are loaded
-        stop = rindex(self.selected_rows, True) + 1
-        stop = max(stop, max(self.matches.keys(), default=0) + 1)
-
-        self.load_rows(stop)
-        self.highlight_table(force)
-
-    def highlight_table(self, force: bool = False) -> None:
-        """Highlight selected rows/cells in red."""
-        if not force and not any(self.selected_rows) and not self.matches:
-            return  # Nothing to highlight
-
-        # Update all rows based on selected state
-        for row in self.ordered_rows:
-            ridx = int(row.key.value)  # 0-based index
-            is_selected = self.selected_rows[ridx]
-            match_cols = self.matches.get(ridx, set())
-
-            if not force and not is_selected and not match_cols:
-                continue  # No highlight needed for this row
-
-            # Update all cells in this row
-            for col_idx, col in enumerate(self.ordered_columns):
-                if not force and not is_selected and col_idx not in match_cols:
-                    continue  # No highlight needed for this cell
-
-                cell_text: Text = self.get_cell(row.key, col.key)
-                need_update = False
-
-                if is_selected or col_idx in match_cols:
-                    cell_text.style = HIGHLIGHT_COLOR
-                    need_update = True
-                elif force:
-                    # Restore original style based on dtype
-                    dtype = self.df.schema[col.key.value]
-                    dc = DtypeConfig(dtype)
-                    cell_text.style = dc.style
-                    need_update = True
-
-                # Update the cell in the table
-                if need_update:
-                    self.update_cell(row.key, col.key, cell_text)
-
     # History & Undo
     def create_history(self, description: str) -> None:
         """Create the initial history state."""
@@ -1311,7 +1285,7 @@ class DataFrameTable(DataTable):
         # Restore state
         self.apply_history(history)
 
-        self.notify(f"Reverted: {history.description}", title="Undo")
+        self.notify(f"Reverted: [$success]{history.description}[/]", title="Undo")
 
     def do_redo(self) -> None:
         """Redo the last undone action."""
@@ -1330,7 +1304,7 @@ class DataFrameTable(DataTable):
         # Clear redo state
         self.history = None
 
-        self.notify(f"Reapplied: {description}", title="Redo")
+        self.notify(f"Reapplied: [$success]{description}[/]", title="Redo")
 
     def do_reset(self) -> None:
         """Reset the table to the initial state."""
@@ -1396,7 +1370,7 @@ class DataFrameTable(DataTable):
         fixed_rows, fixed_columns = result
 
         # Add to history
-        self.add_history(f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{fixed_columns}[/] columns")
+        self.add_history(f"Pinned [$success]{fixed_rows}[/] rows and [$accent]{fixed_columns}[/] columns")
 
         # Apply the pin settings to the table
         if fixed_rows >= 0:
@@ -1404,7 +1378,7 @@ class DataFrameTable(DataTable):
         if fixed_columns >= 0:
             self.fixed_columns = fixed_columns
 
-        # self.notify(f"Pinned [$accent]{fixed_rows}[/] rows and [$success]{fixed_columns}[/] columns", title="Pin")
+        # self.notify(f"Pinned [$success]{fixed_rows}[/] rows and [$accent]{fixed_columns}[/] columns", title="Pin")
 
     def do_hide_column(self) -> None:
         """Hide the currently selected column from the table display."""
@@ -1425,7 +1399,7 @@ class DataFrameTable(DataTable):
         if col_idx >= len(self.columns):
             self.move_cursor(column=len(self.columns) - 1)
 
-        # self.notify(f"Hid column [$accent]{col_name}[/]. Press [$success]H[/] to show hidden columns", title="Hide")
+        # self.notify(f"Hid column [$success]{col_name}[/]. Press [$accent]H[/] to show hidden columns", title="Hide")
 
     def do_expand_column(self) -> None:
         """Expand the current column to show the widest cell in the loaded data."""
@@ -1461,7 +1435,9 @@ class DataFrameTable(DataTable):
 
             # self.notify(f"Expanded column [$success]{col_name}[/] to width [$accent]{max_width}[/]", title="Expand")
         except Exception as e:
-            self.notify("Error expanding column", title="Expand", severity="error")
+            self.notify(
+                f"Error expanding column [$error]{col_name}[/]", title="Expand Column", severity="error", timeout=10
+            )
             self.log(f"Error expanding column `{col_name}`: {str(e)}")
 
     def do_show_hidden_rows_columns(self) -> None:
@@ -1487,7 +1463,7 @@ class DataFrameTable(DataTable):
         self.setup_table()
 
         self.notify(
-            f"Showed [$accent]{hidden_row_count}[/] hidden row(s) and/or [$accent]{hidden_col_count}[/] column(s)",
+            f"Showed [$success]{hidden_row_count}[/] hidden row(s) and/or [$accent]{hidden_col_count}[/] column(s)",
             title="Show",
         )
 
@@ -1595,10 +1571,15 @@ class DataFrameTable(DataTable):
             col_key = col_name
             self.update_cell(row_key, col_key, formatted_value, update_width=True)
 
-            # self.notify(f"Cell updated to [$success]{cell_value}[/]", title="Edit")
+            # self.notify(f"Cell updated to [$success]{cell_value}[/]", title="Edit Cell")
         except Exception as e:
-            self.notify("Error updating cell", title="Edit", severity="error")
-            self.log(f"Error updating cell: {str(e)}")
+            self.notify(
+                f"Error updating cell ([$error]{ridx}[/], [$accent]{col_name}[/])",
+                title="Edit Cell",
+                severity="error",
+                timeout=10,
+            )
+            self.log(f"Error updating cell ({ridx}, {col_name}): {str(e)}")
 
     def do_edit_column(self) -> None:
         """Open modal to edit the entire column with an expression."""
@@ -1627,7 +1608,9 @@ class DataFrameTable(DataTable):
             try:
                 expr = validate_expr(term, self.df.columns, cidx)
             except Exception as e:
-                self.notify(f"Error validating expression [$error]{term}[/]", title="Edit", severity="error")
+                self.notify(
+                    f"Error validating expression [$error]{term}[/]", title="Edit Column", severity="error", timeout=10
+                )
                 self.log(f"Error validating expression `{term}`: {str(e)}")
                 return
 
@@ -1639,14 +1622,14 @@ class DataFrameTable(DataTable):
                 expr = pl.lit(value)
             except Exception:
                 self.notify(
-                    f"Error converting [$accent]{term}[/] to [$error]{dtype}[/]. Cast to string.",
+                    f"Error converting [$error]{term}[/] to [$accent]{dtype}[/]. Cast to string.",
                     title="Edit",
                     severity="error",
                 )
                 expr = pl.lit(str(term))
 
         # Add to history
-        self.add_history(f"Edited column [$accent]{col_name}[/] with expression", dirty=True)
+        self.add_history(f"Edited column [$success]{col_name}[/] with expression", dirty=True)
 
         try:
             # Apply the expression to the column
@@ -1656,6 +1639,7 @@ class DataFrameTable(DataTable):
                 f"Error applying expression: [$error]{term}[/] to column [$accent]{col_name}[/]",
                 title="Edit",
                 severity="error",
+                timeout=10,
             )
             self.log(f"Error applying expression `{term}` to column `{col_name}`: {str(e)}")
             return
@@ -1663,7 +1647,7 @@ class DataFrameTable(DataTable):
         # Recreate table for display
         self.setup_table()
 
-        # self.notify(f"Column [$accent]{col_name}[/] updated with [$success]{expr}[/]", title="Edit")
+        # self.notify(f"Column [$accent]{col_name}[/] updated with [$success]{expr}[/]", title="Edit Column")
 
     def do_rename_column(self) -> None:
         """Open modal to rename the selected column."""
@@ -1690,7 +1674,7 @@ class DataFrameTable(DataTable):
             return
 
         # Add to history
-        self.add_history(f"Renamed column [$accent]{col_name}[/] to [$success]{new_name}[/]", dirty=True)
+        self.add_history(f"Renamed column [$success]{col_name}[/] to [$accent]{new_name}[/]", dirty=True)
 
         # Rename the column in the dataframe
         self.df = self.df.rename({col_name: new_name})
@@ -1738,10 +1722,15 @@ class DataFrameTable(DataTable):
 
             self.update_cell(row_key, col_key, formatted_value)
 
-            # self.notify(f"Cell cleared to [$success]{NULL_DISPLAY}[/]", title="Clear")
+            # self.notify(f"Cell cleared to [$success]{NULL_DISPLAY}[/]", title="Clear Cell")
         except Exception as e:
-            self.notify("Error clearing cell", title="Clear", severity="error")
-            self.log(f"Error clearing cell: {str(e)}")
+            self.notify(
+                f"Error clearing cell ([$error]{ridx}[/], [$accent]{col_name}[/])",
+                title="Clear Cell",
+                severity="error",
+                timeout=10,
+            )
+            self.log(f"Error clearing cell ({ridx}, {col_name}): {str(e)}")
             raise e
 
     def do_add_column(self, col_name: str = None, col_value: pl.Expr = None) -> None:
@@ -1760,7 +1749,7 @@ class DataFrameTable(DataTable):
             new_name = col_name
 
         # Add to history
-        self.add_history(f"Added column [$success]{new_name}[/] after column {cidx + 1}", dirty=True)
+        self.add_history(f"Added column [$success]{new_name}[/] after column [$accent]{cidx + 1}[/]", dirty=True)
 
         try:
             # Create an empty column (all None values)
@@ -1786,8 +1775,8 @@ class DataFrameTable(DataTable):
 
             # self.notify(f"Added column [$success]{new_name}[/]", title="Add Column")
         except Exception as e:
-            self.notify("Error adding column", title="Add Column", severity="error")
-            self.log(f"Error adding column: {str(e)}")
+            self.notify(f"Error adding column [$error]{new_name}[/]", title="Add Column", severity="error", timeout=10)
+            self.log(f"Error adding column `{new_name}`: {str(e)}")
             raise e
 
     def do_add_column_expr(self) -> None:
@@ -1806,7 +1795,7 @@ class DataFrameTable(DataTable):
         cidx, new_col_name, expr = result
 
         # Add to history
-        self.add_history(f"Added column [$success]{new_col_name}[/] with expression {expr}.", dirty=True)
+        self.add_history(f"Added column [$success]{new_col_name}[/] with expression [$accent]{expr}[/].", dirty=True)
 
         try:
             # Create the column
@@ -1829,7 +1818,9 @@ class DataFrameTable(DataTable):
 
             # self.notify(f"Added column [$success]{col_name}[/]", title="Add Column")
         except Exception as e:
-            self.notify("Error adding column", title="Add Column", severity="error")
+            self.notify(
+                f"Error adding column [$error]{new_col_name}[/]", title="Add Column", severity="error", timeout=10
+            )
             self.log(f"Error adding column `{new_col_name}`: {str(e)}")
 
     def do_add_link_column(self) -> None:
@@ -1858,7 +1849,7 @@ class DataFrameTable(DataTable):
         cidx, new_col_name, link_template = result
 
         self.add_history(
-            f"Added link column [$accent]{new_col_name}[/] with template [$success]{link_template}[/].", dirty=True
+            f"Added link column [$success]{new_col_name}[/] with template [$accent]{link_template}[/].", dirty=True
         )
 
         try:
@@ -1894,7 +1885,9 @@ class DataFrameTable(DataTable):
             self.notify(f"Added link column [$success]{new_col_name}[/]. Use Ctrl/Cmd click to open.", title="Add Link")
 
         except Exception as e:
-            self.notify(f"Error adding link column [$error]{new_col_name}[/]", title="Add Link", severity="error")
+            self.notify(
+                f"Error adding link column [$error]{new_col_name}[/]", title="Add Link", severity="error", timeout=10
+            )
             self.log(f"Error adding link column: {str(e)}")
 
     def do_delete_column(self, more: str = None) -> None:
@@ -1999,7 +1992,7 @@ class DataFrameTable(DataTable):
         # Move cursor to the new duplicated column
         self.move_cursor(column=col_idx + 1)
 
-        # self.notify(f"Duplicated column [$accent]{col_name}[/] as [$success]{new_col_name}[/]", title="Duplicate")
+        # self.notify(f"Duplicated column [$success]{col_name}[/] as [$accent]{new_col_name}[/]", title="Duplicate")
 
     def do_delete_row(self, more: str = None) -> None:
         """Delete rows from the table and dataframe.
@@ -2046,7 +2039,7 @@ class DataFrameTable(DataTable):
         try:
             df = self.df.with_row_index(RIDX).filter(predicates)
         except Exception as e:
-            self.notify(f"Error deleting row(s): {e}", title="Delete", severity="error")
+            self.notify(f"Error deleting row(s): {e}", title="Delete", severity="error", timeout=10)
             self.histories.pop()  # Remove last history entry
             return
 
@@ -2065,7 +2058,7 @@ class DataFrameTable(DataTable):
 
         deleted_count = old_count - len(self.df)
         if deleted_count > 0:
-            self.notify(f"Deleted [$accent]{deleted_count}[/] row(s)", title="Delete")
+            self.notify(f"Deleted [$success]{deleted_count}[/] row(s)", title="Delete")
 
     def do_duplicate_row(self) -> None:
         """Duplicate the currently selected row, inserting it right after the current row."""
@@ -2137,7 +2130,8 @@ class DataFrameTable(DataTable):
 
         # Add to history
         self.add_history(
-            f"Moved column [$success]{col_name}[/] {direction} (swapped with [$success]{swap_name}[/])", dirty=True
+            f"Moved column [$success]{col_name}[/] [$accent]{direction}[/] (swapped with [$success]{swap_name}[/])",
+            dirty=True,
         )
 
         # Swap columns in the table's internal column locations
@@ -2192,7 +2186,7 @@ class DataFrameTable(DataTable):
 
         # Add to history
         self.add_history(
-            f"Moved row [$success]{row_key.value}[/] {direction} (swapped with row [$success]{swap_key.value}[/])",
+            f"Moved row [$success]{row_key.value}[/] [$accent]{direction}[/] (swapped with row [$success]{swap_key.value}[/])",
             dirty=True,
         )
 
@@ -2244,12 +2238,12 @@ class DataFrameTable(DataTable):
         try:
             target_dtype = eval(dtype)
         except Exception:
-            self.notify(f"Invalid target data type: [$error]{dtype}[/]", title="Cast", severity="error")
+            self.notify(f"Invalid target data type: [$error]{dtype}[/]", title="Cast", severity="error", timeout=10)
             return
 
         if current_dtype == target_dtype:
             self.notify(
-                f"Column [$accent]{col_name}[/] is already of type [$success]{target_dtype}[/]",
+                f"Column [$warning]{col_name}[/] is already of type [$accent]{target_dtype}[/]",
                 title="Cast",
                 severity="warning",
             )
@@ -2257,7 +2251,7 @@ class DataFrameTable(DataTable):
 
         # Add to history
         self.add_history(
-            f"Cast column [$accent]{col_name}[/] from [$success]{current_dtype}[/] to [$success]{target_dtype}[/]",
+            f"Cast column [$success]{col_name}[/] from [$accent]{current_dtype}[/] to [$success]{target_dtype}[/]",
             dirty=True,
         )
 
@@ -2268,12 +2262,13 @@ class DataFrameTable(DataTable):
             # Recreate table for display
             self.setup_table()
 
-            self.notify(f"Cast column [$accent]{col_name}[/] to [$success]{target_dtype}[/]", title="Cast")
+            self.notify(f"Cast column [$success]{col_name}[/] to [$accent]{target_dtype}[/]", title="Cast")
         except Exception as e:
             self.notify(
-                f"Error casting column [$accent]{col_name}[/] to [$error]{target_dtype}[/]",
+                f"Error casting column [$error]{col_name}[/] to [$accent]{target_dtype}[/]",
                 title="Cast",
                 severity="error",
+                timeout=10,
             )
             self.log(f"Error casting column `{col_name}`: {str(e)}")
 
@@ -2316,7 +2311,9 @@ class DataFrameTable(DataTable):
             try:
                 expr = validate_expr(term, self.df.columns, cidx)
             except Exception as e:
-                self.notify(f"Error validating expression [$error]{term}[/]", title="Search", severity="error")
+                self.notify(
+                    f"Error validating expression [$error]{term}[/]", title="Search", severity="error", timeout=10
+                )
                 self.log(f"Error validating expression `{term}`: {str(e)}")
                 return
 
@@ -2340,42 +2337,42 @@ class DataFrameTable(DataTable):
                         term = f"(?i){term}"
                     expr = pl.col(col_name).cast(pl.String).str.contains(term)
                     self.notify(
-                        f"Error converting [$accent]{term}[/] to [$error]{dtype}[/]. Cast to string.",
+                        f"Error converting [$error]{term}[/] to [$accent]{dtype}[/]. Cast to string.",
                         title="Search",
                         severity="warning",
                     )
 
         # Lazyframe for filtering
         lf = self.df.lazy().with_row_index(RIDX)
-        if False in self.visible_rows:
+        if self.has_hidden_rows:
             lf = lf.filter(self.visible_rows)
 
         # Apply filter to get matched row indices
         try:
             matches = set(lf.filter(expr).select(RIDX).collect().to_series().to_list())
         except Exception as e:
-            self.notify(f"Error applying search filter [$error]{term}[/]", title="Search", severity="error")
+            self.notify(f"Error applying search filter [$error]{term}[/]", title="Search", severity="error", timeout=10)
             self.log(f"Error applying search filter `{term}`: {str(e)}")
             return
 
         match_count = len(matches)
         if match_count == 0:
             self.notify(
-                f"No matches found for [$accent]{term}[/]. Try [$warning](?i)abc[/] for case-insensitive search.",
+                f"No matches found for [$warning]{term}[/]. Try [$accent](?i)abc[/] for case-insensitive search.",
                 title="Search",
                 severity="warning",
             )
             return
 
         # Add to history
-        self.add_history(f"Searched [$accent]{term}[/] in column [$success]{col_name}[/]")
+        self.add_history(f"Searched [$success]{term}[/] in column [$accent]{col_name}[/]")
 
         # Update selected rows to include new matches
         for m in matches:
             self.selected_rows[m] = True
 
         # Show notification immediately, then start highlighting
-        self.notify(f"Found [$accent]{match_count}[/] matches for [$success]{term}[/]", title="Search")
+        self.notify(f"Found [$success]{match_count}[/] matches for [$accent]{term}[/]", title="Search")
 
         # Recreate table for display
         self.setup_table()
@@ -2402,7 +2399,7 @@ class DataFrameTable(DataTable):
 
         # Lazyframe for filtering
         lf = self.df.lazy().with_row_index(RIDX)
-        if False in self.visible_rows:
+        if self.has_hidden_rows:
             lf = lf.filter(self.visible_rows)
 
         # Determine which columns to search: single column or all columns
@@ -2420,7 +2417,9 @@ class DataFrameTable(DataTable):
                 try:
                     expr = validate_expr(term, self.df.columns, col_idx)
                 except Exception as e:
-                    self.notify(f"Error validating expression [$error]{term}[/]", title="Find", severity="error")
+                    self.notify(
+                        f"Error validating expression [$error]{term}[/]", title="Find", severity="error", timeout=10
+                    )
                     self.log(f"Error validating expression `{term}`: {str(e)}")
                     return matches
             else:
@@ -2434,7 +2433,7 @@ class DataFrameTable(DataTable):
             try:
                 matched_ridxs = lf.filter(expr).select(RIDX).collect().to_series().to_list()
             except Exception as e:
-                self.notify(f"Error applying filter: {expr}", title="Find", severity="error")
+                self.notify(f"Error applying filter: [$error]{expr}[/]", title="Find", severity="error", timeout=10)
                 self.log(f"Error applying filter: {str(e)}")
                 return matches
 
@@ -2485,27 +2484,27 @@ class DataFrameTable(DataTable):
         try:
             matches = self.find_matches(term, cidx, match_nocase, match_whole)
         except Exception as e:
-            self.notify(f"Error finding matches for [$error]{term}[/]", title="Find", severity="error")
+            self.notify(f"Error finding matches for [$error]{term}[/]", title="Find", severity="error", timeout=10)
             self.log(f"Error finding matches for `{term}`: {str(e)}")
             return
 
         if not matches:
             self.notify(
-                f"No matches found for [$accent]{term}[/] in current column. Try [$warning](?i)abc[/] for case-insensitive search.",
+                f"No matches found for [$warning]{term}[/] in current column. Try [$accent](?i)abc[/] for case-insensitive search.",
                 title="Find",
                 severity="warning",
             )
             return
 
         # Add to history
-        self.add_history(f"Found [$accent]{term}[/] in column [$success]{col_name}[/]")
+        self.add_history(f"Found [$success]{term}[/] in column [$accent]{col_name}[/]")
 
         # Add to matches and count total
         match_count = sum(len(col_idxs) for col_idxs in matches.values())
         for ridx, col_idxs in matches.items():
             self.matches[ridx].update(col_idxs)
 
-        self.notify(f"Found [$accent]{match_count}[/] matches for [$success]{term}[/]", title="Find")
+        self.notify(f"Found [$success]{match_count}[/] matches for [$accent]{term}[/]", title="Find")
 
         # Recreate table for display
         self.setup_table()
@@ -2519,13 +2518,13 @@ class DataFrameTable(DataTable):
         try:
             matches = self.find_matches(term, cidx=None, match_nocase=match_nocase, match_whole=match_whole)
         except Exception as e:
-            self.notify(f"Error finding matches for [$error]{term}[/]", title="Find", severity="error")
+            self.notify(f"Error finding matches for [$error]{term}[/]", title="Find", severity="error", timeout=10)
             self.log(f"Error finding matches for `{term}`: {str(e)}")
             return
 
         if not matches:
             self.notify(
-                f"No matches found for [$accent]{term}[/] in any column. Try [$warning](?i)abc[/] for case-insensitive search.",
+                f"No matches found for [$warning]{term}[/] in any column. Try [$accent](?i)abc[/] for case-insensitive search.",
                 title="Global Find",
                 severity="warning",
             )
@@ -2540,7 +2539,7 @@ class DataFrameTable(DataTable):
             self.matches[ridx].update(col_idxs)
 
         self.notify(
-            f"Found [$accent]{match_count}[/] matches for [$success]{term}[/] across all columns", title="Global Find"
+            f"Found [$success]{match_count}[/] matches for [$accent]{term}[/] across all columns", title="Global Find"
         )
 
         # Recreate table for display
@@ -2690,7 +2689,7 @@ class DataFrameTable(DataTable):
 
         # Add to history
         self.add_history(
-            f"Replaced [$accent]{term_find}[/] with [$success]{term_replace}[/] in column [$accent]{col_name}[/]"
+            f"Replaced [$success]{term_find}[/] with [$accent]{term_replace}[/] in column [$success]{col_name}[/]"
         )
 
         # Update matches
@@ -2728,9 +2727,10 @@ class DataFrameTable(DataTable):
 
         except Exception as e:
             self.notify(
-                f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]",
+                f"Error replacing [$error]{term_find}[/] with [$accent]{term_replace}[/]",
                 title="Replace",
                 severity="error",
+                timeout=10,
             )
             self.log(f"Error replacing `{term_find}` with `{term_replace}`: {str(e)}")
 
@@ -2806,7 +2806,7 @@ class DataFrameTable(DataTable):
 
         col_name = "all columns" if state.cidx is None else self.df.columns[state.cidx]
         self.notify(
-            f"Replaced [$accent]{state.replaced_occurrence}[/] of [$accent]{state.total_occurrence}[/] in [$success]{col_name}[/]",
+            f"Replaced [$success]{state.replaced_occurrence}[/] of [$accent]{state.total_occurrence}[/] in [$s]{col_name}[/]",
             title="Replace",
         )
 
@@ -2817,9 +2817,10 @@ class DataFrameTable(DataTable):
             self.show_next_replace_confirmation()
         except Exception as e:
             self.notify(
-                f"Error replacing [$accent]{term_find}[/] with [$error]{term_replace}[/]",
+                f"Error replacing [$error]{term_find}[/] with [$accent]{term_replace}[/]",
                 title="Replace",
                 severity="error",
+                timeout=10,
             )
             self.log(f"Error in interactive replace: {str(e)}")
 
@@ -2829,7 +2830,7 @@ class DataFrameTable(DataTable):
         if state.done:
             # All done - show final notification
             col_name = "all columns" if state.cidx is None else self.df.columns[state.cidx]
-            msg = f"Replaced [$accent]{state.replaced_occurrence}[/] of [$accent]{state.total_occurrence}[/] in [$success]{col_name}[/]"
+            msg = f"Replaced [$success]{state.replaced_occurrence}[/] of [$accent]{state.total_occurrence}[/] in [$success]{col_name}[/]"
             if state.skipped_occurrence > 0:
                 msg += f", [$warning]{state.skipped_occurrence}[/] skipped"
             self.notify(msg, title="Replace")
@@ -2928,7 +2929,7 @@ class DataFrameTable(DataTable):
         # Add to history
         self.add_history("Toggled row selection")
 
-        if False in self.visible_rows:
+        if self.has_hidden_rows:
             # Some rows are hidden - invert only selected visible rows and clear selections for hidden rows
             for i in range(len(self.selected_rows)):
                 if self.visible_rows[i]:
@@ -2941,7 +2942,7 @@ class DataFrameTable(DataTable):
 
         # Check if we're highlighting or un-highlighting
         if new_selected_count := self.selected_rows.count(True):
-            self.notify(f"Toggled selection for [$accent]{new_selected_count}[/] rows", title="Toggle")
+            self.notify(f"Toggled selection for [$success]{new_selected_count}[/] rows", title="Toggle")
 
         # Recreate table for display
         self.setup_table()
@@ -2991,40 +2992,42 @@ class DataFrameTable(DataTable):
         # Recreate table for display
         self.setup_table()
 
-        self.notify(f"Cleared selections for [$accent]{row_count}[/] rows", title="Clear")
+        self.notify(f"Cleared selections for [$success]{row_count}[/] rows", title="Clear")
 
     # Filter & View
     def do_filter_rows(self) -> None:
-        """Keep only the rows with selections and matches, and remove others."""
-        if not any(self.selected_rows) and not self.matches:
-            self.notify("No rows to filter", title="Filter", severity="warning")
-            return
+        """Keep only the rows with selections and cell matches, and remove others."""
+        if any(self.selected_rows) or self.matches:
+            message = "Filter to rows with selection and cell matches (other rows removed)"
+            filter_expr = [
+                True if (selected or ridx in self.matches) else False
+                for ridx, selected in enumerate(self.selected_rows)
+            ]
+        else:  # Search cursor value in current column
+            message = "Filter to rows matching cursor value (other rows removed)"
+            ridx = self.cursor_row_idx
+            cidx = self.cursor_col_idx
+            value = self.df.item(ridx, cidx)
 
-        filter_expr = [
-            True if (selected or ridx in self.matches) else False for ridx, selected in enumerate(self.selected_rows)
-        ]
+            col_name = self.df.columns[cidx]
+            if value is None:
+                filter_expr = pl.col(col_name).is_null()
+            else:
+                filter_expr = pl.col(col_name) == value
 
         # Add to history
-        self.add_history("Filtered to selections and matches", dirty=True)
+        self.add_history(message, dirty=True)
 
         # Apply filter to dataframe with row indices
         df_filtered = self.df.with_row_index(RIDX).filter(filter_expr)
 
-        # Update selections and matches
-        self.selected_rows = [self.selected_rows[ridx] for ridx in df_filtered[RIDX]]
-        self.matches = {
-            idx: self.matches[ridx].copy() for idx, ridx in enumerate(df_filtered[RIDX]) if ridx in self.matches
-        }
-
         # Update dataframe
-        self.df = df_filtered.drop(RIDX)
+        self.reset_df(df_filtered.drop(RIDX))
 
         # Recreate table for display
         self.setup_table()
 
-        self.notify(
-            f"Removed rows without selections or matches. Now showing [$accent]{len(self.df)}[/] rows", title="Filter"
-        )
+        self.notify(f"{message}. Now showing [$success]{len(self.df)}[/] rows", title="Filter")
 
     def do_view_rows(self) -> None:
         """View rows.
@@ -3034,6 +3037,7 @@ class DataFrameTable(DataTable):
         """
 
         cidx = self.cursor_col_idx
+        col_name = self.df.columns[cidx]
 
         # If there are rows with selections or matches, use those
         if any(self.selected_rows) or self.matches:
@@ -3043,7 +3047,8 @@ class DataFrameTable(DataTable):
         # Otherwise, use the current cell value
         else:
             ridx = self.cursor_row_idx
-            term = str(self.df.item(ridx, cidx))
+            value = self.df.item(ridx, cidx)
+            term = pl.col(col_name).is_null() if value is None else pl.col(col_name) == value
 
         self.view_rows((term, cidx, False, True))
 
@@ -3051,10 +3056,11 @@ class DataFrameTable(DataTable):
         """Open the filter screen to enter an expression."""
         ridx = self.cursor_row_idx
         cidx = self.cursor_col_idx
-        cursor_value = str(self.df.item(ridx, cidx))
+        cursor_value = self.df.item(ridx, cidx)
+        term = NULL if cursor_value is None else str(cursor_value)
 
         self.app.push_screen(
-            FilterScreen(self.df, cidx, cursor_value),
+            FilterScreen(self.df, cidx, term),
             callback=self.view_rows,
         )
 
@@ -3066,17 +3072,22 @@ class DataFrameTable(DataTable):
 
         col_name = self.df.columns[cidx]
 
-        if term == NULL:
-            expr = pl.col(col_name).is_null()
+        # Support for polars expression
+        if isinstance(term, pl.Expr):
+            expr = term
+        # Support for list of booleans (selected rows)
         elif isinstance(term, (list, pl.Series)):
-            # Support for list of booleans (selected rows)
             expr = term
+        elif term == NULL:
+            expr = pl.col(col_name).is_null()
         elif tentative_expr(term):
-            # Support for polars expressions
+            # Support for polars expression in string form
             try:
                 expr = validate_expr(term, self.df.columns, cidx)
             except Exception as e:
-                self.notify(f"Error validating expression [$error]{term}[/]", title="Filter", severity="error")
+                self.notify(
+                    f"Error validating expression [$error]{term}[/]", title="Filter", severity="error", timeout=10
+                )
                 self.log(f"Error validating expression `{term}`: {str(e)}")
                 return
         else:
@@ -3105,20 +3116,17 @@ class DataFrameTable(DataTable):
         lf = self.df.lazy().with_row_index(RIDX)
 
         # Apply existing visibility filter first
-        if False in self.visible_rows:
+        if self.has_hidden_rows:
             lf = lf.filter(self.visible_rows)
 
-        if isinstance(expr, (list, pl.Series)):
-            expr_str = str(list(expr)[:10]) + ("..." if len(expr) > 10 else "")
-        else:
-            expr_str = str(expr)
+        expr_str = "boolean list or series" if isinstance(expr, (list, pl.Series)) else str(expr)
 
         # Apply the filter expression
         try:
             df_filtered = lf.filter(expr).collect()
         except Exception as e:
             self.histories.pop()  # Remove last history entry
-            self.notify(f"Error applying filter [$error]{expr_str}[/]", title="Filter", severity="error")
+            self.notify(f"Error applying filter [$error]{expr_str}[/]", title="Filter", severity="error", timeout=10)
             self.log(f"Error applying filter `{expr_str}`: {str(e)}")
             return
 
@@ -3128,7 +3136,7 @@ class DataFrameTable(DataTable):
             return
 
         # Add to history
-        self.add_history(f"Filtered by expression [$success]{expr_str}[/]", dirty=True)
+        self.add_history(f"Filtered by expression [$success]{expr_str}[/]")
 
         # Mark unfiltered rows as invisible
         filtered_row_indices = set(df_filtered[RIDX].to_list())
@@ -3140,7 +3148,7 @@ class DataFrameTable(DataTable):
         # Recreate table for display
         self.setup_table()
 
-        self.notify(f"Filtered to [$accent]{matched_count}[/] matching rows", title="Filter")
+        self.notify(f"Filtered to [$success]{matched_count}[/] matching rows", title="Filter")
 
     # Copy & Save
     def do_copy_to_clipboard(self, content: str, message: str) -> None:
@@ -3164,7 +3172,7 @@ class DataFrameTable(DataTable):
             )
             self.notify(message, title="Clipboard")
         except FileNotFoundError:
-            self.notify("Error copying to clipboard", title="Clipboard", severity="error")
+            self.notify("Error copying to clipboard", title="Clipboard", severity="error", timeout=10)
 
     def do_save_to_file(
         self, title: str = "Save to File", all_tabs: bool | None = None, task_after_save: str | None = None
@@ -3217,24 +3225,39 @@ class DataFrameTable(DataTable):
         """Actually save the dataframe to a file."""
         filepath = Path(filename)
         ext = filepath.suffix.lower()
+        if ext.endswith(".gz"):
+            ext = Path(filename).with_suffix("").suffix.lower()
+
+        fmt = ext.removeprefix(".")
+        if fmt not in SUPPORTED_FORMATS:
+            self.notify(
+                f"Unsupported file format [$success]{fmt}[/]. Use [$accent]CSV[/] as fallback. Supported formats: {', '.join(SUPPORTED_FORMATS)}",
+                title="Save to File",
+                severity="warning",
+            )
+            fmt = "csv"
 
         # Add to history
         self.add_history(f"Saved dataframe to [$success]{filename}[/]")
 
         try:
-            if ext in (".xlsx", ".xls"):
-                self.save_excel(filename)
-            elif ext in (".tsv", ".tab"):
+            if fmt == "csv":
+                self.df.write_csv(filename)
+            elif fmt in ("tsv", "tab"):
                 self.df.write_csv(filename, separator="\t")
-            elif ext == ".json":
+            elif fmt in ("xlsx", "xls"):
+                self.save_excel(filename)
+            elif fmt == "json":
                 self.df.write_json(filename)
-            elif ext == ".parquet":
+            elif fmt == "ndjson":
+                self.df.write_ndjson(filename)
+            elif fmt == "parquet":
                 self.df.write_parquet(filename)
-            else:
+            else:  # Fallback to CSV
                 self.df.write_csv(filename)
 
-            self.dataframe = self.df  # Update original dataframe
-            self.filename = filename  # Update current filename
+            # Update current filename
+            self.filename = filename
 
             # Reset dirty flag after save
             if self._all_tabs:
@@ -3256,7 +3279,7 @@ class DataFrameTable(DataTable):
                 self.notify(f"Saved current tab to [$success]{filename}[/]", title="Save to File")
 
         except Exception as e:
-            self.notify(f"Error saving [$error]{filename}[/]", title="Save to File", severity="error")
+            self.notify(f"Error saving [$error]{filename}[/]", title="Save to File", severity="error", timeout=10)
             self.log(f"Error saving file `{filename}`: {str(e)}")
 
     def save_excel(self, filename: str) -> None:
@@ -3325,7 +3348,7 @@ class DataFrameTable(DataTable):
         # Execute the SQL query
         try:
             lf = self.df.lazy().with_row_index(RIDX)
-            if False in self.visible_rows:
+            if self.has_hidden_rows:
                 lf = lf.filter(self.visible_rows)
 
             df_filtered = lf.sql(sql).collect()
@@ -3337,7 +3360,7 @@ class DataFrameTable(DataTable):
                 return
 
             # Add to history
-            self.add_history(f"SQL Query:\n[$accent]{sql}[/]", dirty=not view)
+            self.add_history(f"SQL Query:\n[$success]{sql}[/]", dirty=not view)
 
             if view:
                 # Just view - do not modify the dataframe