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

dataframe_textual/table_screen.py

@@ -13,7 +13,7 @@ from textual.renderables.bar import Bar
 from textual.screen import ModalScreen
 from textual.widgets import DataTable
 
-from .common import NULL, NULL_DISPLAY, RIDX, DtypeConfig, format_float, format_row
+from .common import NULL, NULL_DISPLAY, RID, DtypeConfig, format_float
 
 
 class TableScreen(ModalScreen):
@@ -45,9 +45,6 @@ class TableScreen(ModalScreen):
 
         Args:
             dftable: Reference to the parent DataFrameTable widget.
-
-        Returns:
-            None
         """
         super().__init__()
         self.dftable = dftable  # DataFrameTable
@@ -71,9 +68,6 @@ class TableScreen(ModalScreen):
 
         Subclasses should implement this method to populate the DataTable
         with appropriate columns and rows based on the specific screen's purpose.
-
-        Returns:
-            None
         """
         raise NotImplementedError("Subclasses must implement build_table method.")
 
@@ -85,9 +79,6 @@ class TableScreen(ModalScreen):
 
         Args:
             event: The key event object.
-
-        Returns:
-            None
         """
         if event.key in ("q", "escape"):
             self.app.pop_screen()
@@ -97,60 +88,55 @@ 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.lazy().filter(expr).collect()
+        self.log(f"Filtered dataframe has {len(df_filtered)} rows")
 
-        # Apply the action
+        ok_rids = set(df_filtered[RID].to_list())
+        if not ok_rids:
+            self.notify(
+                f"No matches found for [$warning]{col_name}[/] == {value_display}",
+                title="No Matches",
+                severity="warning",
+            )
+            return
+
+        # Action filter
         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
-            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()
+            self.dftable.do_filter_rows()
+
+        # Action view
+        else:
+            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."""
@@ -166,9 +152,6 @@ class RowDetailScreen(TableScreen):
 
         Populates the table with column names and values from the selected row
         of the main DataFrame. Sets the table cursor type to "row".
-
-        Returns:
-            None
         """
         self.build_table()
 
@@ -180,14 +163,14 @@ class RowDetailScreen(TableScreen):
 
         # Get all columns and values from the dataframe row
         for col, val, dtype in zip(self.df.columns, self.df.row(self.ridx), self.df.dtypes):
-            self.table.add_row(
-                *format_row(
-                    [col, val],
-                    [None, dtype],
-                    apply_justify=False,
-                    thousand_separator=self.thousand_separator,
-                )
-            )
+            if col in self.dftable.hidden_columns or col == RID:
+                continue  # Skip RID column
+            formatted_row = []
+            formatted_row.append(col)
+
+            dc = DtypeConfig(dtype)
+            formatted_row.append(dc.format(val, justify="", thousand_separator=self.thousand_separator))
+            self.table.add_row(*formatted_row)
 
         self.table.cursor_type = "row"
 
@@ -199,30 +182,41 @@ 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":
+        elif event.key == "right_curly_bracket":  # '}'
+            # Move to the next row
+            ridx = self.ridx + 1
+            if ridx < len(self.df):
+                self.ridx = ridx
+                self.dftable.move_cursor_to(self.ridx)
+                self.build_table()
+            event.stop()
+        elif event.key == "left_curly_bracket":  # '{'
+            # Move to the previous row
+            ridx = self.ridx - 1
+            if ridx >= 0:
+                self.ridx = ridx
+                self.dftable.move_cursor_to(self.ridx)
+                self.build_table()
             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,24 +238,20 @@ 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()
 
-        # Apply only to visible rows
-        if False in self.dftable.visible_rows:
-            lf = lf.filter(self.dftable.visible_rows)
-
         # Get column statistics
-        stats_df = lf.select(pl.col(col_name)).collect().describe()
+        stats_df = lf.select(pl.col(col_name)).describe()
         if len(stats_df) == 0:
             return
 
@@ -277,35 +267,21 @@ class StatisticsScreen(TableScreen):
         # Add rows
         for row in stats_df.rows():
             stat_label, stat_value = row
-            value = stat_value
-            if stat_value is None:
-                value = NULL_DISPLAY
-            elif dc.gtype == "integer" and self.thousand_separator:
-                value = f"{stat_value:,}"
-            elif dc.gtype == "float":
-                value = format_float(stat_value, self.thousand_separator)
-            else:
-                value = str(stat_value)
-
             self.table.add_row(
-                Text(stat_label, justify="left"),
-                Text(value, style=dc.style, justify=dc.justify),
+                stat_label,
+                dc.format(stat_value, thousand_separator=self.thousand_separator),
             )
 
-    def _build_dataframe_stats(self) -> None:
+    def build_dataframe_stats(self) -> None:
         """Build statistics for the entire dataframe."""
-        lf = self.df.lazy()
-
-        # Apply only to visible rows
-        if False in self.dftable.visible_rows:
-            lf = lf.filter(self.dftable.visible_rows)
+        lf = self.df.lazy().select(pl.exclude(RID))
 
         # Apply only to non-hidden columns
         if self.dftable.hidden_columns:
             lf = lf.select(pl.exclude(self.dftable.hidden_columns))
 
         # Get dataframe statistics
-        stats_df = lf.collect().describe()
+        stats_df = lf.describe()
 
         # Add columns for each dataframe column with appropriate styling
         for idx, (col_name, col_dtype) in enumerate(zip(stats_df.columns, stats_df.dtypes), 0):
@@ -331,17 +307,7 @@ class StatisticsScreen(TableScreen):
                 col_dtype = stats_df.dtypes[idx]
                 dc = DtypeConfig(col_dtype)
 
-                value = stat_value
-                if stat_value is None:
-                    value = NULL_DISPLAY
-                elif dc.gtype == "integer" and self.thousand_separator:
-                    value = f"{stat_value:,}"
-                elif dc.gtype == "float":
-                    value = format_float(stat_value, self.thousand_separator)
-                else:
-                    value = str(stat_value)
-
-                formatted_row.append(Text(value, style=dc.style, justify=dc.justify))
+                formatted_row.append(dc.format(stat_value, thousand_separator=self.thousand_separator))
 
             self.table.add_row(*formatted_row)
 
@@ -351,16 +317,14 @@ 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.sorted_columns = {
-            1: True,  # Count
-        }
+        self.cidx = cidx
+        self.sorted_columns = {1: True}  # Count sort by default
+        self.total_count = len(dftable.df)
 
-        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)
+        col = dftable.df.columns[self.cidx]
+        self.df: pl.DataFrame = dftable.df.lazy().select(pl.col(col).value_counts(sort=True)).unnest(col).collect()
 
     def on_mount(self) -> None:
         """Create the frequency table."""
@@ -369,19 +333,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 +353,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
@@ -414,33 +378,18 @@ class FrequencyScreen(TableScreen):
             self.table.add_column(Text(header_text, justify=justify), key=key)
 
         # Get style config for Int64 and Float64
-        ds_int = DtypeConfig(pl.Int64)
-        ds_float = DtypeConfig(pl.Float64)
+        dc_int = DtypeConfig(pl.Int64)
+        dc_float = DtypeConfig(pl.Float64)
 
         # Add rows to the frequency table
         for row_idx, row in enumerate(self.df.rows()):
             column, count = row
             percentage = (count / self.total_count) * 100
 
-            if column is None:
-                value = NULL_DISPLAY
-            elif dc.gtype == "integer" and self.thousand_separator:
-                value = f"{column:,}"
-            elif dc.gtype == "float":
-                value = format_float(column, self.thousand_separator)
-            else:
-                value = str(column)
-
             self.table.add_row(
-                Text(value, style=dc.style, justify=dc.justify),
-                Text(
-                    f"{count:,}" if self.thousand_separator else str(count), style=ds_int.style, justify=ds_int.justify
-                ),
-                Text(
-                    format_float(percentage, self.thousand_separator),
-                    style=ds_float.style,
-                    justify=ds_float.justify,
-                ),
+                dc.format(column),
+                dc_int.format(count, thousand_separator=self.thousand_separator),
+                dc_float.format(percentage, thousand_separator=self.thousand_separator),
                 Bar(
                     highlight_range=(0.0, percentage / 100 * 10),
                     width=10,
@@ -457,7 +406,7 @@ class FrequencyScreen(TableScreen):
                 justify="right",
             ),
             Text(
-                format_float(100.0, self.thousand_separator),
+                format_float(100.0, self.thousand_separator, precision=-2 if len(self.df) > 1 else 2),
                 style="bold",
                 justify="right",
             ),
@@ -468,7 +417,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 +442,86 @@ 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
+
+
+class MetaShape(TableScreen):
+    """Modal screen to display metadata about the dataframe."""
+
+    CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "MetadataScreen")
+
+    def on_mount(self) -> None:
+        """Initialize the metadata screen.
+
+        Populates the table with metadata information about the dataframe,
+        including row and column counts.
+        """
+        self.build_table()
+
+    def build_table(self) -> None:
+        """Build the metadata table."""
+        self.table.clear(columns=True)
+        self.table.add_column("")
+        self.table.add_column(Text("Count", justify="right"))
+
+        # Get shape information
+        num_rows, num_cols = self.df.shape if self.dftable.df_view is None else self.dftable.df_view.shape
+        num_cols -= 1  # Exclude RID column
+        dc_int = DtypeConfig(pl.Int64)
+
+        # Add rows to the table
+        self.table.add_row("Row", dc_int.format(num_rows, thousand_separator=self.thousand_separator))
+        self.table.add_row("Column", dc_int.format(num_cols, thousand_separator=self.thousand_separator))
+
+        self.table.cursor_type = "none"
+
+
+class MetaColumnScreen(TableScreen):
+    """Modal screen to display metadata about the columns in the dataframe."""
+
+    CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "MetaColumnScreen")
+
+    def on_mount(self) -> None:
+        """Initialize the column metadata screen.
+
+        Populates the table with information about each column in the dataframe,
+        including ID (1-based index), Name, and Type.
+        """
+        self.build_table()
+
+    def build_table(self) -> None:
+        """Build the column metadata table."""
+        self.table.clear(columns=True)
+        self.table.add_column("Column")
+        self.table.add_column("Name")
+        self.table.add_column("Type")
+
+        # Get schema information
+        schema = self.df.schema
+        dc_int = DtypeConfig(pl.Int64)
+        dc_str = DtypeConfig(pl.String)
+
+        # Add a row for each column
+        for idx, (col_name, col_type) in enumerate(schema.items(), 1):
+            if col_name == RID:
+                continue  # Skip RID column
+
+            dc = DtypeConfig(col_type)
+            self.table.add_row(
+                dc_int.format(idx, thousand_separator=self.thousand_separator),
+                col_name,
+                dc_str.format("Datetime" if str(col_type).startswith("Datetime") else col_type, style=dc.style),
+            )
+
+        self.table.cursor_type = "none"