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

dataframe_textual/data_frame_table.py

@@ -916,6 +916,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,18 +948,7 @@ 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
@@ -3010,20 +3020,15 @@ class DataFrameTable(DataTable):
         # 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"
+            f"Filtered rows with selections or matches and removed others. Now showing [$accent]{len(self.df)}[/] rows",
+            title="Filter",
         )
 
     def do_view_rows(self) -> None:
@@ -3043,7 +3048,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 = NULL if value is None else str(value)
 
         self.view_rows((term, cidx, False, True))
 
@@ -3051,10 +3057,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,
         )
 
@@ -3108,10 +3115,7 @@ class DataFrameTable(DataTable):
         if False in self.visible_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:
@@ -3128,7 +3132,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())

dataframe_textual/data_frame_viewer.py

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

{dataframe_textual-1.9.0.dist-info → dataframe_textual-1.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataframe-textual
-Version: 1.9.0
+Version: 1.10.1
 Summary: Interactive terminal viewer/editor for tabular data
 Project-URL: Homepage, https://github.com/need47/dataframe-textual
 Project-URL: Repository, https://github.com/need47/dataframe-textual.git

dataframe_textual-1.10.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+dataframe_textual/__init__.py,sha256=IFPb8RMUgghw0eRomehkkC684Iny_gs1VkiZMQ5ZpFk,813
+dataframe_textual/__main__.py,sha256=VRH80gWJGLxfURg1GiN3cwWI7O_TQM5PqhqXbUCC1bg,3253
+dataframe_textual/common.py,sha256=fh5dkN06VgFMItgFMlB7BMdiBjalc24jdqaGTJI7yCM,25409
+dataframe_textual/data_frame_help_panel.py,sha256=iEKaur-aH1N_oqHu-vMwEEjfkjQiThK24UO5izsOiW0,3416
+dataframe_textual/data_frame_table.py,sha256=bzKD7PKz2CP7HeZIqUkpDYZHhx7amBaEzHWRlq2i3XY,127578
+dataframe_textual/data_frame_viewer.py,sha256=4fPIj-dvqhoTRxxOPfwTfRpYcfle7VtwTZfP4sJHA6E,21254
+dataframe_textual/sql_screen.py,sha256=Pk2ENyDVkOXBLcsEMeXOEMkdzRH_NJ3T1biVUcY8j4Q,7411
+dataframe_textual/table_screen.py,sha256=IhaGAWjzXaLvvc4JLBlAM6_Hl3t7du7vuHQYhrvW_5o,18055
+dataframe_textual/yes_no_screen.py,sha256=qbuhywLIGBL52zQfSGVZQCfsdSmDz9JH6C4YFLrLYKU,26233
+dataframe_textual-1.10.1.dist-info/METADATA,sha256=F0pCwiggF6y2WVr9Fs4YDgII5Rh-JZHuGeJq1y5AQpA,30381
+dataframe_textual-1.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dataframe_textual-1.10.1.dist-info/entry_points.txt,sha256=R_GoooOxcq6ab4RaHiVoZ4zrZJ-phMcGmlL2rwqncW8,107
+dataframe_textual-1.10.1.dist-info/licenses/LICENSE,sha256=AVTg0gk1X-LHI-nnHlAMDQetrwuDZK4eypgSMDO46Yc,1069
+dataframe_textual-1.10.1.dist-info/RECORD,,

dataframe_textual-1.9.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-dataframe_textual/__init__.py,sha256=IFPb8RMUgghw0eRomehkkC684Iny_gs1VkiZMQ5ZpFk,813
-dataframe_textual/__main__.py,sha256=VRH80gWJGLxfURg1GiN3cwWI7O_TQM5PqhqXbUCC1bg,3253
-dataframe_textual/common.py,sha256=fh5dkN06VgFMItgFMlB7BMdiBjalc24jdqaGTJI7yCM,25409
-dataframe_textual/data_frame_help_panel.py,sha256=iEKaur-aH1N_oqHu-vMwEEjfkjQiThK24UO5izsOiW0,3416
-dataframe_textual/data_frame_table.py,sha256=GfjknW0xzjEyz6syIW_BvCLBjGdEZpn1jW87PefBlOo,127408
-dataframe_textual/data_frame_viewer.py,sha256=WI6e6AujRQkfCk2yerIRhuiTwtn86y1yWg3WesqdmAs,21315
-dataframe_textual/sql_screen.py,sha256=9s9V-pcyYvXoaqsW_85hs-JSsllzayqhENC6ETGq7Xw,7464
-dataframe_textual/table_screen.py,sha256=t2eNYS4a-G95qxRU9CFSM8kFjm-STIzkcP_o998ilqY,18135
-dataframe_textual/yes_no_screen.py,sha256=HF2Z1WgOEof7NdA_u0s3pCxP26n69Kr6sQWwQvjK-YE,26247
-dataframe_textual-1.9.0.dist-info/METADATA,sha256=bE00p7b3HACIwJzqeHRt28F99qMyruWKNEaxzm8wGVk,30380
-dataframe_textual-1.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dataframe_textual-1.9.0.dist-info/entry_points.txt,sha256=R_GoooOxcq6ab4RaHiVoZ4zrZJ-phMcGmlL2rwqncW8,107
-dataframe_textual-1.9.0.dist-info/licenses/LICENSE,sha256=AVTg0gk1X-LHI-nnHlAMDQetrwuDZK4eypgSMDO46Yc,1069
-dataframe_textual-1.9.0.dist-info/RECORD,,