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

dataframe_textual/data_frame_viewer.py

@@ -36,7 +36,7 @@ class DataFrameViewer(App):
         - **Ctrl+A** - 💾 Save all tabs to file
         - **Ctrl+D** - 📋 Duplicate current tab
         - **Ctrl+O** - 📁 Open a file
-        - **Double-click tab** - ✏️ Rename current tab
+        - **Double-click tab** - ✏️ Rename tab
 
         ## 🎨 View & Settings
         - **F1** - ❓ Toggle this help panel
@@ -81,10 +81,6 @@ class DataFrameViewer(App):
         ContentTab.dirty {
             background: $warning-darken-3;
         }
-
-        .underline--bar {
-            color: red;
-        }
     """
 
     def __init__(self, *sources: Source) -> None:

dataframe_textual/sql_screen.py

@@ -157,11 +157,8 @@ class SimpleSqlScreen(SqlScreen):
         """
         super().__init__(
             dftable,
-            on_yes_callback=self._handle_simple,
-            on_maybe_callback=partial(
-                self._handle_simple,
-                view=False,
-            ),
+            on_yes_callback=self.handle_simple,
+            on_maybe_callback=partial(self.handle_simple, view=False),
         )
 
     def compose(self) -> ComposeResult:
@@ -177,7 +174,7 @@ class SimpleSqlScreen(SqlScreen):
             yield Input(placeholder="e.g., age > 30 and height < 180", id="where-input")
             yield from super().compose()
 
-    def _handle_simple(self, view: bool = True) -> None:
+    def handle_simple(self, view: bool = True) -> None:
         """Handle Yes button/Enter key press."""
         selections = self.query_one(SelectionList).selected
         if not selections:
@@ -221,8 +218,8 @@ class AdvancedSqlScreen(SqlScreen):
         """
         super().__init__(
             dftable,
-            on_yes_callback=self._handle_advanced,
-            on_maybe_callback=partial(self._handle_advanced, view=False),
+            on_yes_callback=self.handle_advanced,
+            on_maybe_callback=partial(self.handle_advanced, view=False),
         )
 
     def compose(self) -> ComposeResult:
@@ -236,6 +233,6 @@ class AdvancedSqlScreen(SqlScreen):
             )
             yield from super().compose()
 
-    def _handle_advanced(self, view: bool = True) -> None:
+    def handle_advanced(self, view: bool = True) -> None:
         """Handle Yes button/Enter key press."""
         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

@@ -494,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,