dataframe-textual 0.3.0__tar.gz → 0.3.2__tar.gz

{dataframe_textual-0.3.0 → dataframe_textual-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataframe-textual
-Version: 0.3.0
+Version: 0.3.2
 Summary: Interactive CSV/Excel viewer for the terminal (Textual TUI)
 Project-URL: Homepage, https://github.com/need47/dataframe-textual
 Project-URL: Repository, https://github.com/need47/dataframe-textual.git

{dataframe_textual-0.3.0 → dataframe_textual-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dataframe-textual"
-version = "0.3.0"
+version = "0.3.2"
 description = "Interactive CSV/Excel viewer for the terminal (Textual TUI)"
 readme = "README.md"
 requires-python = ">=3.11"

{dataframe_textual-0.3.0 → dataframe_textual-0.3.2}/src/dataframe_textual/data_frame_table.py

@@ -549,7 +549,7 @@ class DataFrameTable(DataTable):
             return
 
         # Push the modal screen
-        self.app.push_screen(RowDetailScreen(row_idx, self.df))
+        self.app.push_screen(RowDetailScreen(row_idx, self))
 
     def _show_frequency(self) -> None:
         """Show frequency distribution for the current column."""
@@ -558,9 +558,7 @@ class DataFrameTable(DataTable):
             return
 
         # Push the frequency modal screen
-        self.app.push_screen(
-            FrequencyScreen(col_idx, self.df.filter(self.visible_rows))
-        )
+        self.app.push_screen(FrequencyScreen(col_idx, self))
 
     def _open_freeze_screen(self) -> None:
         """Open the freeze screen to set fixed rows and columns."""
@@ -579,7 +577,7 @@ class DataFrameTable(DataTable):
 
         # Add to history
         self._add_history(
-            f"Pinned [on $primary]{fixed_rows}[/] rows and [on $primary]{fixed_columns}[/] columns"
+            f"Pinned [$accent]{fixed_rows}[/] rows and [$accent]{fixed_columns}[/] columns"
         )
 
         # Apply the pin settings to the table
@@ -589,7 +587,7 @@ class DataFrameTable(DataTable):
             self.fixed_columns = fixed_columns
 
         self.app.notify(
-            f"Pinned [on $primary]{fixed_rows}[/] rows and [on $primary]{fixed_columns}[/] columns",
+            f"Pinned [$accent]{fixed_rows}[/] rows and [$accent]{fixed_columns}[/] columns",
             title="Pin",
         )
 
@@ -1109,7 +1107,7 @@ class DataFrameTable(DataTable):
                 self.update_cell(row_key, col_key, cell_text)
 
         self.app.notify(
-            f"Found [on $success]{match_count}[/] matches for [on $primary]{term}[/] across all columns",
+            f"Found [$accent]{match_count}[/] matches for [on $primary]{term}[/] across all columns",
             title="Global Search",
         )
 
@@ -1143,7 +1141,7 @@ class DataFrameTable(DataTable):
         # Check if we're highlighting or un-highlighting
         if new_selected_count := self.selected_rows.count(True):
             self.app.notify(
-                f"Toggled selection - now showing [on $primary]{new_selected_count}[/] rows",
+                f"Toggled selection - now showing [$accent]{new_selected_count}[/] rows",
                 title="Toggle",
             )
 
@@ -1167,7 +1165,7 @@ class DataFrameTable(DataTable):
         self._highlight_rows(clear=True)
 
         self.app.notify(
-            f"Cleared [on $primary]{selected_count}[/] selected rows", title="Clear"
+            f"Cleared [$accent]{selected_count}[/] selected rows", title="Clear"
         )
 
     def _filter_selected_rows(self) -> None:
@@ -1190,7 +1188,7 @@ class DataFrameTable(DataTable):
         self._setup_table()
 
         self.app.notify(
-            f"Removed unselected rows. Now showing [on $primary]{selected_count}[/] rows",
+            f"Removed unselected rows. Now showing [$accent]{selected_count}[/] rows",
             title="Filter",
         )
 
@@ -1255,7 +1253,7 @@ class DataFrameTable(DataTable):
         self._setup_table()
 
         self.app.notify(
-            f"Filtered to [on $primary]{matched_count}[/] matching rows",
+            f"Filtered to [$accent]{matched_count}[/] matching rows",
             title="Filter",
         )
 

{dataframe_textual-0.3.0 → dataframe_textual-0.3.2}/src/dataframe_textual/data_frame_viewer.py

@@ -117,7 +117,9 @@ class DataFrameViewer(App):
     def on_key(self, event):
         if event.key == "k":
             self.theme = _next(list(BUILTIN_THEMES.keys()), self.theme)
-            self.notify(f"Switched to theme: [$primary]{self.theme}[/]", title="Theme")
+            self.notify(
+                f"Switched to theme: [on $primary]{self.theme}[/]", title="Theme"
+            )
 
     def on_tabbed_content_tab_activated(
         self, event: TabbedContent.TabActivated
@@ -202,12 +204,24 @@ class DataFrameViewer(App):
 
     def _add_tab(self, df: pl.DataFrame, filename: str) -> None:
         """Add new table tab. If single file, replace table; if multiple, add tab."""
-        table = DataFrameTable(df, filename, zebra_stripes=True)
         tabname = Path(filename).stem
         if any(tab.name == tabname for tab in self.tabs):
             tabname = f"{tabname}_{len(self.tabs) + 1}"
 
-        tab = TabPane(tabname, table, name=tabname, id=f"tab_{len(self.tabs) + 1}")
+        # Find an available tab index
+        tab_idx = f"tab_{len(self.tabs) + 1}"
+        for idx in range(len(self.tabs)):
+            pending_tab_idx = f"tab_{idx + 1}"
+            if any(tab.id == pending_tab_idx for tab in self.tabs):
+                continue
+
+            tab_idx = pending_tab_idx
+            break
+
+        table = DataFrameTable(
+            df, filename, zebra_stripes=True, id=tab_idx, name=tabname
+        )
+        tab = TabPane(tabname, table, name=tabname, id=tab_idx)
         self.tabbed.add_pane(tab)
         self.tabs[tab] = table
 
@@ -226,6 +240,7 @@ class DataFrameViewer(App):
             else:
                 if active_pane := self.tabbed.active_pane:
                     self.tabbed.remove_pane(active_pane.id)
+                    self.tabs.pop(active_pane)
                     self.notify(
                         f"Closed tab [on $primary]{active_pane.name}[/]", title="Close"
                     )

{dataframe_textual-0.3.0 → dataframe_textual-0.3.2}/src/dataframe_textual/table_screen.py

@@ -1,6 +1,9 @@
 """Modal screens for displaying data in tables (row details and frequency)."""
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .data_frame_table import DataFrameTable
 
 import polars as pl
 from rich.text import Text
@@ -10,7 +13,7 @@ from textual.renderables.bar import Bar
 from textual.screen import ModalScreen
 from textual.widgets import DataTable
 
-from .common import BOOLS, DtypeConfig, _format_row
+from .common import DtypeConfig, _format_row
 
 
 class TableScreen(ModalScreen):
@@ -33,14 +36,14 @@ class TableScreen(ModalScreen):
         }
     """
 
-    def __init__(self, df: pl.DataFrame, id: str | None = None):
+    def __init__(self, dftable: DataFrameTable):
         super().__init__()
-        self.df = df
-        self.id = id
+        self.df: pl.DataFrame = dftable.df  # Polars DataFrame
+        self.dftable = dftable  # DataFrameTable
 
     def compose(self) -> ComposeResult:
         """Create the table. Must be overridden by subclasses."""
-        self.table = DataTable(zebra_stripes=True, id=self.id)
+        self.table = DataTable(zebra_stripes=True)
         yield self.table
 
     def on_key(self, event):
@@ -87,27 +90,26 @@ class TableScreen(ModalScreen):
             expr = pl.col(col_name) == col_value
             value_display = f"[on $primary]{col_value}[/]"
 
-        app = self.app
         matched_indices = set(
-            app.df.with_row_index("__rid__").filter(expr)["__rid__"].to_list()
+            self.dftable.df.with_row_index("__rid__").filter(expr)["__rid__"].to_list()
         )
 
         # Apply the action
         if action == "filter":
             # Update visible_rows to reflect the filter
-            for i in range(len(app.visible_rows)):
-                app.visible_rows[i] = i in matched_indices
+            for i in range(len(self.dftable.visible_rows)):
+                self.dftable.visible_rows[i] = i in matched_indices
             title = "Filter"
             message = f"Filtered by [on $primary]{col_name}[/] = {value_display}"
         else:  # action == "highlight"
             # Update selected_rows to reflect the highlights
-            for i in range(len(app.selected_rows)):
-                app.selected_rows[i] = i in matched_indices
+            for i in range(len(self.dftable.selected_rows)):
+                self.dftable.selected_rows[i] = i in matched_indices
             title = "Highlight"
             message = f"Highlighted [on $primary]{col_name}[/] = {value_display}"
 
         # Recreate the table display with updated data in the main app
-        app._setup_table()
+        self.dftable._setup_table()
 
         # Dismiss the frequency screen
         self.app.pop_screen()
@@ -120,8 +122,8 @@ class RowDetailScreen(TableScreen):
 
     CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "RowDetailScreen")
 
-    def __init__(self, row_idx: int, df: pl.DataFrame):
-        super().__init__(df, id="row-detail-table")
+    def __init__(self, row_idx: int, dftable):
+        super().__init__(dftable)
         self.row_idx = row_idx
 
     def on_mount(self) -> None:
@@ -169,25 +171,54 @@ class FrequencyScreen(TableScreen):
 
     CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "FrequencyScreen")
 
-    def __init__(self, col_idx: int, df: pl.DataFrame):
-        super().__init__(df, id="frequency-table")
+    def __init__(self, col_idx: int, dftable: DataFrameTable):
+        super().__init__(dftable)
         self.col_idx = col_idx
         self.sorted_columns = {
             1: True,  # Count
             2: True,  # %
         }
+        self.df: pl.DataFrame = (
+            dftable.df[dftable.df.columns[self.col_idx]]
+            .value_counts(sort=True)
+            .sort("count", descending=True)
+        )
 
     def on_mount(self) -> None:
         """Create the frequency table."""
-        column = self.df.columns[self.col_idx]
-        dtype = str(self.df.dtypes[self.col_idx])
+        self.build_table()
+
+    def on_key(self, event):
+        if event.key == "left_square_bracket":  # '['
+            # Sort by current column in ascending order
+            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)
+            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"
+            )
+            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"
+            )
+            event.stop()
+
+    def build_table(self) -> None:
+        # Create frequency table
+        column = self.dftable.df.columns[self.col_idx]
+        dtype = str(self.dftable.df.dtypes[self.col_idx])
         dc = DtypeConfig(dtype)
 
         # Calculate frequencies using Polars
-        freq_df = self.df[column].value_counts(sort=True).sort("count", descending=True)
-        total_count = len(self.df)
+        total_count = len(self.dftable.df)
 
-        # Create frequency table
         self.table.add_column(Text(column, justify=dc.justify), key=column)
         self.table.add_column(Text("Count", justify="right"), key="Count")
         self.table.add_column(Text("%", justify="right"), key="%")
@@ -198,7 +229,7 @@ class FrequencyScreen(TableScreen):
         ds_float = DtypeConfig("Float64")
 
         # Add rows to the frequency table
-        for row_idx, row in enumerate(freq_df.rows()):
+        for row_idx, row in enumerate(self.df.rows()):
             value, count = row
             percentage = (count / total_count) * 100
 
@@ -226,39 +257,22 @@ class FrequencyScreen(TableScreen):
             Text("Total", style="bold", justify=dc.justify),
             Text(f"{total_count:,}", style="bold", justify="right"),
             Text("100.00", style="bold", justify="right"),
+            Bar(
+                highlight_range=(0.0, 10),
+                width=10,
+            ),
             key="total",
         )
 
-    def on_key(self, event):
-        if event.key == "left_square_bracket":  # '['
-            # Sort by current column in ascending order
-            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)
-            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"
-            )
-            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"
-            )
-            event.stop()
-
     def _sort_by_column(self, descending: bool) -> None:
         """Sort the dataframe by the selected column and refresh the main table."""
-        freq_table = self.query_one(DataTable)
 
-        col_idx = freq_table.cursor_column
-        col_dtype = "String"
+        self.log(self.df)
+
+        row_idx, col_idx = self.table.cursor_coordinate
+        col_sort = col_idx if col_idx == 0 else 1
 
-        sort_dir = self.sorted_columns.get(col_idx)
+        sort_dir = self.sorted_columns.get(col_sort)
         if sort_dir is not None:
             # If already sorted in the same direction, do nothing
             if sort_dir == descending:
@@ -268,34 +282,16 @@ class FrequencyScreen(TableScreen):
                 return
 
         self.sorted_columns.clear()
-        self.sorted_columns[col_idx] = descending
-
-        if col_idx == 0:
-            col_name = self.df.columns[self.col_idx]
-            col_dtype = str(self.df.dtypes[self.col_idx])
-        elif col_idx == 1:
-            col_name = "Count"
-            col_dtype = "Int64"
-        elif col_idx == 2:
-            col_name = "%"
-            col_dtype = "Float64"
-
-        def key_fun(freq_col):
-            col_value = freq_col.plain
-
-            if col_dtype == "Int64":
-                return int(col_value)
-            elif col_dtype == "Float64":
-                return float(col_value)
-            elif col_dtype == "Boolean":
-                return BOOLS[col_value]
-            else:
-                return col_value
-
-        # Sort the table
-        freq_table.sort(
-            col_name, key=lambda freq_col: key_fun(freq_col), reverse=descending
-        )
+        self.sorted_columns[col_sort] = descending
+
+        col_name = self.df.columns[col_sort]
+        self.df = self.df.sort(col_name, descending=descending)
+
+        # Rebuild the frequency table
+        self.table.clear(columns=True)
+        self.build_table()
+
+        self.table.move_cursor(row=row_idx, column=col_idx)
 
         # Notify the user
         order = "desc" if descending else "asc"

{dataframe_textual-0.3.0 → dataframe_textual-0.3.2}/src/dataframe_textual/yes_no_screen.py

@@ -65,7 +65,7 @@ class YesNoScreen(ModalScreen):
             input: Optional input value to pre-fill an Input widget. If None, no Input is shown. If it is a 2-value tuple, the first value is the pre-filled input, and the second value is the type of input (e.g., "integer", "number", "text")
             yes: Text for the Yes button. If None, hides the Yes button
             no: Text for the No button. If None, hides the No button
-            on_yes_callback: Optional callable that takes no args and returns the value to dismiss with
+            on_yes_callback: Optional callable that takes no args and returns the value to dismiss with when Yes is pressed
         """
         super().__init__()
         self.title = title
@@ -179,7 +179,7 @@ class ConfirmScreen(YesNoScreen):
         )
 
     def handle_confirm(self) -> None:
-        self.dismiss(True)
+        return True
 
 
 class EditCellScreen(YesNoScreen):
@@ -218,20 +218,18 @@ class EditCellScreen(YesNoScreen):
 
         # Check if value changed
         if new_value_str == self.input_value:
-            self.dismiss(None)
             self.notify("No changes made", title="Edit", severity="warning")
-            return
+            return None
 
         # Parse and validate based on column dtype
         try:
             new_value = DtypeConfig(self.col_dtype).convert(new_value_str)
         except Exception as e:
-            self.dismiss(None)  # Dismiss without changes
             self.notify(f"Invalid value: {str(e)}", title="Edit", severity="error")
-            return
+            return None
 
-        # Dismiss with the new value
-        self.dismiss((self.row_key, self.col_idx, new_value))
+        # New value
+        return self.row_key, self.col_idx, new_value
 
 
 class SearchScreen(YesNoScreen):
@@ -265,8 +263,8 @@ class SearchScreen(YesNoScreen):
             self.notify("Search term cannot be empty", title="Search", severity="error")
             return
 
-        # Dismiss with the search term
-        self.dismiss((term, self.col_dtype, self.col_name))
+        # Search term
+        return term, self.col_dtype, self.col_name
 
 
 class FilterScreen(YesNoScreen):
@@ -303,20 +301,20 @@ class FilterScreen(YesNoScreen):
                 # Test the expression by evaluating it
                 expr = eval(expr_str, {"pl": pl})
 
-                # Dismiss with the expression
-                self.dismiss((expr, expr_str))
+                # Expression is valid
+                return expr, expr_str
             except Exception as e:
                 self.notify(
                     f"Error evaluating expression: {str(e)}",
                     title="Filter",
                     severity="error",
                 )
-                self.dismiss(None)
         except ValueError as ve:
             self.notify(
                 f"Invalid expression: {str(ve)}", title="Filter", severity="error"
             )
-            self.dismiss(None)
+
+        return None
 
 
 class FreezeScreen(YesNoScreen):

{dataframe_textual-0.3.0 → dataframe_textual-0.3.2}/uv.lock

@@ -171,7 +171,7 @@ wheels = [
 
 [[package]]
 name = "dataframe-textual"
-version = "0.3.0"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "polars" },