dataframe-textual 1.5.0__py3-none-any.whl → 1.10.1__py3-none-any.whl

dataframe_textual/sql_screen.py

@@ -1,5 +1,6 @@
 """Modal screens for Polars sql manipulation"""
 
+from functools import partial
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -46,18 +47,20 @@ class SqlScreen(ModalScreen):
 
     """
 
-    def __init__(self, dftable: "DataFrameTable", on_yes_callback=None) -> None:
+    def __init__(self, dftable: "DataFrameTable", on_yes_callback=None, on_maybe_callback=None) -> None:
         """Initialize the SQL screen."""
         super().__init__()
         self.dftable = dftable  # DataFrameTable
         self.df: pl.DataFrame = dftable.df  # Polars DataFrame
         self.on_yes_callback = on_yes_callback
+        self.on_maybe_callback = on_maybe_callback
 
     def compose(self) -> ComposeResult:
         """Compose the SQL screen widget structure."""
         # Shared by subclasses
         with Horizontal(id="button-container"):
-            yield Button("Apply", id="yes", variant="success")
+            yield Button("View", id="yes", variant="success")
+            yield Button("Filter", id="maybe", variant="warning")
             yield Button("Cancel", id="no", variant="error")
 
     def on_key(self, event) -> None:
@@ -66,7 +69,16 @@ class SqlScreen(ModalScreen):
             self.app.pop_screen()
             event.stop()
         elif event.key == "enter":
-            self._handle_yes()
+            for button in self.query(Button):
+                if button.has_focus:
+                    if button.id == "yes":
+                        self._handle_yes()
+                    elif button.id == "maybe":
+                        self._handle_maybe()
+                    break
+            else:
+                self._handle_yes()
+
             event.stop()
         elif event.key == "escape":
             self.dismiss(None)
@@ -76,6 +88,8 @@ class SqlScreen(ModalScreen):
         """Handle button press events in the SQL screen."""
         if event.button.id == "yes":
             self._handle_yes()
+        elif event.button.id == "maybe":
+            self._handle_maybe()
         elif event.button.id == "no":
             self.dismiss(None)
 
@@ -87,6 +101,14 @@ class SqlScreen(ModalScreen):
         else:
             self.dismiss(True)
 
+    def _handle_maybe(self) -> None:
+        """Handle Maybe button press."""
+        if self.on_maybe_callback:
+            result = self.on_maybe_callback()
+            self.dismiss(result)
+        else:
+            self.dismiss(True)
+
 
 class SimpleSqlScreen(SqlScreen):
     """Simple SQL query screen."""
@@ -133,25 +155,35 @@ class SimpleSqlScreen(SqlScreen):
         Returns:
             None
         """
-        super().__init__(dftable, on_yes_callback=self._handle_simple)
+        super().__init__(
+            dftable,
+            on_yes_callback=self.handle_simple,
+            on_maybe_callback=partial(self.handle_simple, view=False),
+        )
 
     def compose(self) -> ComposeResult:
         """Compose the simple SQL screen widget structure."""
         with Container(id="sql-container") as container:
             container.border_title = "SQL Query"
             yield Label("Select columns (default to all):", id="select-label")
-            yield SelectionList(*[Selection(col, col) for col in self.df.columns], id="column-selection")
+            yield SelectionList(
+                *[Selection(col, col) for col in self.df.columns if col not in self.dftable.hidden_columns],
+                id="column-selection",
+            )
             yield Label("Where condition (optional)", id="where-label")
             yield Input(placeholder="e.g., age > 30 and height < 180", id="where-input")
             yield from super().compose()
 
-    def _handle_simple(self) -> None:
+    def handle_simple(self, view: bool = True) -> None:
         """Handle Yes button/Enter key press."""
         selections = self.query_one(SelectionList).selected
-        columns = ", ".join(f"`{s}`" for s in selections) if selections else "*"
+        if not selections:
+            selections = [col for col in self.df.columns if col not in self.dftable.hidden_columns]
+
+        columns = ", ".join(f"`{s}`" for s in selections)
         where = self.query_one(Input).value.strip()
 
-        return columns, where
+        return columns, where, view
 
 
 class AdvancedSqlScreen(SqlScreen):
@@ -184,7 +216,11 @@ class AdvancedSqlScreen(SqlScreen):
         Returns:
             None
         """
-        super().__init__(dftable, on_yes_callback=self._handle_advanced)
+        super().__init__(
+            dftable,
+            on_yes_callback=self.handle_advanced,
+            on_maybe_callback=partial(self.handle_advanced, view=False),
+        )
 
     def compose(self) -> ComposeResult:
         """Compose the advanced SQL screen widget structure."""
@@ -197,6 +233,6 @@ class AdvancedSqlScreen(SqlScreen):
             )
             yield from super().compose()
 
-    def _handle_advanced(self) -> None:
+    def handle_advanced(self, view: bool = True) -> None:
         """Handle Yes button/Enter key press."""
-        return self.query_one(TextArea).text.strip()
+        return self.query_one(TextArea).text.strip(), view

dataframe_textual/table_screen.py

@@ -97,60 +97,61 @@ class TableScreen(ModalScreen):
             self.build_table()
             event.stop()
 
-    def _filter_or_highlight_selected_value(
-        self, col_name_value: tuple[str, Any] | None, action: str = "filter"
-    ) -> None:
-        """Apply filter or highlight action by the selected value.
+    def filter_or_view_selected_value(self, cidx_name_value: tuple[int, str, Any] | None, action: str = "view") -> None:
+        """Apply filter or view action by the selected value.
 
-        Filters or highlights rows in the main table based on a selected value from
+        Filters or views rows in the main table based on a selected value from
         this table (typically frequency or row detail). Updates the main table's display
         and notifies the user of the action.
 
         Args:
-            col_name_value: Tuple of (column_name, column_value) to filter/highlight by, or None.
-            action: Either "filter" to hide non-matching rows, or "highlight" to select matching rows. Defaults to "filter".
-
-        Returns:
-            None
+            col_name_value: Tuple of (column_name, column_value) to filter/view by, or None.
+            action: Either "filter" to hide non-matching rows, or "view" to show matching rows. Defaults to "view".
         """
-        if col_name_value is None:
+        if cidx_name_value is None:
             return
-        col_name, col_value = col_name_value
+        cidx, col_name, col_value = cidx_name_value
+        self.log(f"Filtering or viewing by {col_name} == {col_value}")
 
         # Handle NULL values
         if col_value == NULL:
             # Create expression for NULL values
             expr = pl.col(col_name).is_null()
-            value_display = "[$success]NULL[/]"
+            value_display = f"[$success]{NULL_DISPLAY}[/]"
         else:
             # Create expression for the selected value
             expr = pl.col(col_name) == col_value
             value_display = f"[$success]{col_value}[/]"
 
-        matched_indices = set(self.dftable.df.with_row_index(RIDX).filter(expr)[RIDX].to_list())
+        df_filtered = self.dftable.df.with_row_index(RIDX).filter(expr)
+        self.log(f"Filtered dataframe has {len(df_filtered)} rows")
+
+        matched_indices = set(df_filtered[RIDX].to_list())
+        if not matched_indices:
+            self.notify(
+                f"No matches found for [$warning]{col_name}[/] == {value_display}",
+                title="No Matches",
+                severity="warning",
+            )
+            return
 
         # Apply the action
         if action == "filter":
-            # Update visible_rows to reflect the filter
-            for i in range(len(self.dftable.visible_rows)):
-                self.dftable.visible_rows[i] = i in matched_indices
-            title = "Filter"
-            message = f"Filtered by [$accent]{col_name}[/] == [$success]{value_display}[/]"
-        else:  # action == "highlight"
-            # Update selected_rows to reflect the highlights
+            # Update selections
             for i in range(len(self.dftable.selected_rows)):
                 self.dftable.selected_rows[i] = i in matched_indices
-            title = "Highlight"
-            message = f"Highlighted [$accent]{col_name}[/] == [$success]{value_display}[/]"
 
-        # Recreate the table display with updated data in the main app
-        self.dftable._setup_table()
+            # Update main table display
+            self.dftable.do_filter_rows()
+
+        else:  # action == "view"
+            # Update visible rows
+            expr = [i in matched_indices for i in range(len(self.dftable.df))]
+            self.dftable.view_rows((expr, cidx, False, True))
 
         # Dismiss the frequency screen
         self.app.pop_screen()
 
-        self.notify(message, title=title)
-
 
 class RowDetailScreen(TableScreen):
     """Modal screen to display a single row's details."""
@@ -199,30 +200,27 @@ class RowDetailScreen(TableScreen):
 
         Args:
             event: The key event object.
-
-        Returns:
-            None
         """
         if event.key == "v":
-            # Filter the main table by the selected value
-            self._filter_or_highlight_selected_value(self._get_col_name_value(), action="filter")
+            # View the main table by the selected value
+            self.filter_or_view_selected_value(self.get_cidx_name_value(), action="view")
             event.stop()
         elif event.key == "quotation_mark":  # '"'
-            # Highlight the main table by the selected value
-            self._filter_or_highlight_selected_value(self._get_col_name_value(), action="highlight")
+            # Filter the main table by the selected value
+            self.filter_or_view_selected_value(self.get_cidx_name_value(), action="filter")
             event.stop()
         elif event.key == "comma":
             event.stop()
 
-    def _get_col_name_value(self) -> tuple[str, Any] | None:
-        row_idx = self.table.cursor_row
-        if row_idx >= len(self.df.columns):
+    def get_cidx_name_value(self) -> tuple[int, str, Any] | None:
+        cidx = self.table.cursor_row
+        if cidx >= len(self.df.columns):
             return None  # Invalid row
 
-        col_name = self.df.columns[row_idx]
-        col_value = self.df.item(self.ridx, row_idx)
+        col_name = self.df.columns[cidx]
+        col_value = self.df.item(self.ridx, cidx)
 
-        return col_name, col_value
+        return cidx, col_name, col_value
 
 
 class StatisticsScreen(TableScreen):
@@ -244,14 +242,14 @@ class StatisticsScreen(TableScreen):
 
         if self.col_idx is None:
             # Dataframe statistics
-            self._build_dataframe_stats()
+            self.build_dataframe_stats()
             self.table.cursor_type = "column"
         else:
             # Column statistics
-            self._build_column_stats()
+            self.build_column_stats()
             self.table.cursor_type = "row"
 
-    def _build_column_stats(self) -> None:
+    def build_column_stats(self) -> None:
         """Build statistics for a single column."""
         col_name = self.df.columns[self.col_idx]
         lf = self.df.lazy()
@@ -292,7 +290,7 @@ class StatisticsScreen(TableScreen):
                 Text(value, style=dc.style, justify=dc.justify),
             )
 
-    def _build_dataframe_stats(self) -> None:
+    def build_dataframe_stats(self) -> None:
         """Build statistics for the entire dataframe."""
         lf = self.df.lazy()
 
@@ -351,16 +349,16 @@ class FrequencyScreen(TableScreen):
 
     CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "FrequencyScreen")
 
-    def __init__(self, col_idx: int, dftable: "DataFrameTable") -> None:
+    def __init__(self, cidx: int, dftable: "DataFrameTable") -> None:
         super().__init__(dftable)
-        self.col_idx = col_idx
+        self.cidx = cidx
         self.sorted_columns = {
             1: True,  # Count
         }
 
         df = dftable.df.filter(dftable.visible_rows) if False in dftable.visible_rows else dftable.df
         self.total_count = len(df)
-        self.df: pl.DataFrame = df[df.columns[self.col_idx]].value_counts(sort=True).sort("count", descending=True)
+        self.df: pl.DataFrame = df[df.columns[self.cidx]].value_counts(sort=True).sort("count", descending=True)
 
     def on_mount(self) -> None:
         """Create the frequency table."""
@@ -369,19 +367,19 @@ class FrequencyScreen(TableScreen):
     def on_key(self, event):
         if event.key == "left_square_bracket":  # '['
             # Sort by current column in ascending order
-            self._sort_by_column(descending=False)
+            self.sort_by_column(descending=False)
             event.stop()
         elif event.key == "right_square_bracket":  # ']'
             # Sort by current column in descending order
-            self._sort_by_column(descending=True)
+            self.sort_by_column(descending=True)
             event.stop()
         elif event.key == "v":
             # Filter the main table by the selected value
-            self._filter_or_highlight_selected_value(self._get_col_name_value(), action="filter")
+            self.filter_or_view_selected_value(self.get_cidx_name_value(), action="view")
             event.stop()
         elif event.key == "quotation_mark":  # '"'
             # Highlight the main table by the selected value
-            self._filter_or_highlight_selected_value(self._get_col_name_value(), action="highlight")
+            self.filter_or_view_selected_value(self.get_cidx_name_value(), action="filter")
             event.stop()
 
     def build_table(self) -> None:
@@ -389,8 +387,8 @@ class FrequencyScreen(TableScreen):
         self.table.clear(columns=True)
 
         # Create frequency table
-        column = self.dftable.df.columns[self.col_idx]
-        dtype = self.dftable.df.dtypes[self.col_idx]
+        column = self.dftable.df.columns[self.cidx]
+        dtype = self.dftable.df.dtypes[self.cidx]
         dc = DtypeConfig(dtype)
 
         # Add column headers with sort indicators
@@ -468,7 +466,7 @@ class FrequencyScreen(TableScreen):
             key="total",
         )
 
-    def _sort_by_column(self, descending: bool) -> None:
+    def sort_by_column(self, descending: bool) -> None:
         """Sort the dataframe by the selected column and refresh the main table."""
         row_idx, col_idx = self.table.cursor_coordinate
         col_sort = col_idx if col_idx == 0 else 1
@@ -493,15 +491,15 @@ class FrequencyScreen(TableScreen):
         # order = "desc" if descending else "asc"
         # self.notify(f"Sorted by [on $primary]{col_name}[/] ({order})", title="Sort")
 
-    def _get_col_name_value(self) -> tuple[str, str] | None:
+    def get_cidx_name_value(self) -> tuple[str, str, str] | None:
         row_idx = self.table.cursor_row
         if row_idx >= len(self.df[:, 0]):  # first column
             return None  # Skip the last `Total` row
 
-        col_name = self.dftable.df.columns[self.col_idx]
-        col_dtype = self.dftable.df.dtypes[self.col_idx]
+        col_name = self.dftable.df.columns[self.cidx]
+        col_dtype = self.dftable.df.dtypes[self.cidx]
 
         cell_value = self.table.get_cell_at(Coordinate(row_idx, 0))
         col_value = NULL if cell_value.plain == NULL_DISPLAY else DtypeConfig(col_dtype).convert(cell_value.plain)
 
-        return col_name, col_value
+        return self.cidx, col_name, col_value

dataframe_textual/yes_no_screen.py

@@ -5,11 +5,13 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from .data_frame_table import DataFrameTable
 
+
 import polars as pl
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal
 from textual.screen import ModalScreen
-from textual.widgets import Button, Checkbox, Input, Label, Static
+from textual.widgets import Button, Checkbox, Input, Label, Static, TabPane
+from textual.widgets.tabbed_content import ContentTab
 
 from .common import NULL, DtypeConfig, tentative_expr, validate_expr
 
@@ -254,7 +256,18 @@ class YesNoScreen(ModalScreen):
     def on_key(self, event) -> None:
         """Handle key press events in the table screen."""
         if event.key == "enter":
-            self._handle_yes()
+            for button in self.query(Button):
+                if button.has_focus:
+                    if button.id == "yes":
+                        self._handle_yes()
+                    elif button.id == "maybe":
+                        self._handle_maybe()
+                    elif button.id == "no":
+                        self.dismiss(None)
+                    break
+            else:
+                self._handle_yes()
+
             event.stop()
         elif event.key == "escape":
             self.dismiss(None)
@@ -282,18 +295,26 @@ class SaveFileScreen(YesNoScreen):
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "SaveFileScreen")
 
-    def __init__(self, filename: str, title="Save Tab"):
+    def __init__(
+        self, filename: str, title: str = "Save to File", all_tabs: bool | None = None, multi_tab: bool = False
+    ):
+        self.all_tabs = all_tabs or (all_tabs is None and multi_tab)
         super().__init__(
             title=title,
+            label="Enter filename",
             input=filename,
+            yes="Save",
+            maybe="Save All Tabs" if self.all_tabs else None,
+            no="Cancel",
             on_yes_callback=self.handle_save,
+            on_maybe_callback=self.handle_save,
         )
 
     def handle_save(self):
         if self.input:
             input_filename = self.input.value.strip()
             if input_filename:
-                return input_filename
+                return input_filename, self.all_tabs
             else:
                 self.notify("Filename cannot be empty", title="Save", severity="error")
                 return None
@@ -473,13 +494,13 @@ class FilterScreen(YesNoScreen):
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "FilterScreen")
 
-    def __init__(self, df: pl.DataFrame, cidx: int, input_value: str | None = None):
+    def __init__(self, df: pl.DataFrame, cidx: int, term: str | None = None):
         self.df = df
         self.cidx = cidx
         super().__init__(
             title="Filter by Expression",
             label="e.g., NULL, $1 > 50, $name == 'text', $_ > 100, $a < $b, $_.str.contains('sub')",
-            input=input_value,
+            input=term,
             checkbox="Match Nocase",
             checkbox2="Match Whole",
             on_yes_callback=self._get_input,
@@ -587,7 +608,7 @@ class AddColumnScreen(YesNoScreen):
             title="Add Column",
             label="Enter column name",
             input="Link" if link else "Column name",
-            label2="Enter link template, e.g., https://example.com/$1/id/$id, PC/compound/$_"
+            label2="Enter link template, e.g., https://example.com/$_/id/$1, PC/compound/$cid"
             if link
             else "Enter value or Polars expression, e.g., abc, pl.lit(123), NULL, $_ * 2, $1 + $total, $_.str.to_uppercase(), pl.concat_str($_, pl.lit('-suffix'))",
             input2="Link template" if link else "Column value or expression",
@@ -694,3 +715,43 @@ class FindReplaceScreen(YesNoScreen):
         replace_all = True
 
         return term_find, term_replace, match_nocase, match_whole, replace_all
+
+
+class RenameTabScreen(YesNoScreen):
+    """Modal screen to rename a tab."""
+
+    CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "RenameTabScreen")
+
+    def __init__(self, content_tab: ContentTab, existing_tabs: list[TabPane]):
+        self.content_tab = content_tab
+        self.existing_tabs = existing_tabs
+        tab_name = content_tab.label_text
+
+        super().__init__(
+            title="Rename Tab",
+            label="New tab name",
+            input={"value": tab_name},
+            on_yes_callback=self._validate_input,
+        )
+
+    def _validate_input(self) -> None:
+        """Validate and save the new tab name."""
+        new_name = self.input.value.strip()
+
+        # Check if name is empty
+        if not new_name:
+            self.notify("Tab name cannot be empty", title="Rename Tab", severity="error")
+            return None
+
+        # Check if name changed
+        if new_name == self.content_tab.label_text:
+            self.notify("No changes made", title="Rename Tab", severity="warning")
+            return None
+
+        # Check if name already exists
+        if new_name in self.existing_tabs:
+            self.notify(f"Tab [$accent]{new_name}[/] already exists", title="Rename Tab", severity="error")
+            return None
+
+        # Return new name
+        return self.content_tab, new_name