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

dataframe_textual/data_frame_viewer.py

@@ -33,14 +33,17 @@ class DataFrameViewer(App):
         - **Q** - ❌ Close all tabs (prompts to save unsaved changes)
         - **Ctrl+Q** - 🚪 Force to quit app (discards unsaved changes)
         - **Ctrl+T** - 💾 Save current tab to file
+        - **w** - 💾 Save current tab to file (overwrite without prompt)
         - **Ctrl+A** - 💾 Save all tabs to file
+        - **W** - 💾 Save all tabs to file (overwrite without prompt)
         - **Ctrl+D** - 📋 Duplicate current tab
         - **Ctrl+O** - 📁 Open a file
-        - **Double-click tab** - ✏️ Rename current tab
+        - **Double-click** - ✏️ Rename tab
 
         ## 🎨 View & Settings
         - **F1** - ❓ Toggle this help panel
         - **k** - 🌙 Cycle through themes
+        - **Ctrl+P -> Screenshot** - 📸 Capture terminal view as a SVG image
 
         ## ⭐ Features
         - **Multi-file support** - 📂 Open multiple CSV/Excel files as tabs
@@ -62,6 +65,8 @@ class DataFrameViewer(App):
         ("ctrl+o", "open_file", "Open File"),
         ("ctrl+t", "save_current_tab", "Save Current Tab"),
         ("ctrl+a", "save_all_tabs", "Save All Tabs"),
+        ("w", "save_current_tab_overwrite", "Save Current Tab (overwrite)"),
+        ("W", "save_all_tabs_overwrite", "Save All Tabs (overwrite)"),
         ("ctrl+d", "duplicate_tab", "Duplicate Tab"),
         ("greater_than_sign,b", "next_tab(1)", "Next Tab"),  # '>' and 'b'
         ("less_than_sign", "next_tab(-1)", "Prev Tab"),  # '<'
@@ -245,6 +250,11 @@ class DataFrameViewer(App):
         if table := self.get_active_table():
             table.do_save_to_file(title="Save Current Tab", all_tabs=False)
 
+    def action_save_current_tab_overwrite(self) -> None:
+        """Save the currently active tab to file, overwriting if it exists."""
+        if table := self.get_active_table():
+            table.save_to_file((table.filename, False, False))
+
     def action_save_all_tabs(self) -> None:
         """Save all open tabs to their respective files.
 
@@ -253,6 +263,11 @@ class DataFrameViewer(App):
         if table := self.get_active_table():
             table.do_save_to_file(title="Save All Tabs", all_tabs=True)
 
+    def action_save_all_tabs_overwrite(self) -> None:
+        """Save all open tabs to their respective files, overwriting if they exist."""
+        if table := self.get_active_table():
+            table.save_to_file((table.filename, True, False))
+
     def action_duplicate_tab(self) -> None:
         """Duplicate the currently active tab.
 
@@ -269,7 +284,7 @@ class DataFrameViewer(App):
 
         # Create new table with the same dataframe and filename
         new_table = DataFrameTable(
-            table.df,
+            table.df.clone(),
             table.filename,
             tabname=new_tabname,
             zebra_stripes=True,

dataframe_textual/sql_screen.py

@@ -151,9 +151,6 @@ class SimpleSqlScreen(SqlScreen):
 
         Args:
             dftable: Reference to the parent DataFrameTable widget.
-
-        Returns:
-            None
         """
         super().__init__(
             dftable,
@@ -165,12 +162,12 @@ class SimpleSqlScreen(SqlScreen):
         """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 Label("SELECT columns (all if none selected):", id="select-label")
             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 Label("WHERE condition (optional)", id="where-label")
             yield Input(placeholder="e.g., age > 30 and height < 180", id="where-input")
             yield from super().compose()
 
@@ -212,9 +209,6 @@ class AdvancedSqlScreen(SqlScreen):
 
         Args:
             dftable: Reference to the parent DataFrameTable widget.
-
-        Returns:
-            None
         """
         super().__init__(
             dftable,
@@ -227,7 +221,7 @@ class AdvancedSqlScreen(SqlScreen):
         with Container(id="sql-container") as container:
             container.border_title = "Advanced SQL Query"
             yield TextArea.code_editor(
-                placeholder="Enter SQL query (use `self` as the table name), e.g., \n\nSELECT * \nFROM self \nWHERE age > 30",
+                placeholder="Enter SQL query, e.g., \n\nSELECT * \nFROM self \nWHERE age > 30\n\n- use 'self' as the table name\n- use backticks (`) for column names with spaces.",
                 id="sql-textarea",
                 language="sql",
             )

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, RIDX, DtypeConfig, format_float
 
 
 class TableScreen(ModalScreen):
@@ -181,14 +181,12 @@ 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,
-                )
-            )
+            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"
 
@@ -209,7 +207,25 @@ class RowDetailScreen(TableScreen):
             # 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 visible row
+            ridx = self.ridx + 1
+            while ridx < len(self.df) and not self.dftable.visible_rows[ridx]:
+                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 visible row
+            ridx = self.ridx - 1
+            while ridx >= 0 and not self.dftable.visible_rows[ridx]:
+                ridx -= 1
+            if ridx >= 0:
+                self.ridx = ridx
+                self.dftable.move_cursor_to(self.ridx)
+                self.build_table()
             event.stop()
 
     def get_cidx_name_value(self) -> tuple[int, str, Any] | None:
@@ -275,19 +291,9 @@ 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:
@@ -329,17 +335,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)
 
@@ -412,33 +408,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,
@@ -455,7 +436,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",
             ),
@@ -503,3 +484,70 @@ class FrequencyScreen(TableScreen):
         col_value = NULL if cell_value.plain == NULL_DISPLAY else DtypeConfig(col_dtype).convert(cell_value.plain)
 
         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
+        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):
+            dc = DtypeConfig(col_type)
+            self.table.add_row(
+                dc_int.format(idx, thousand_separator=self.thousand_separator),
+                col_name,
+                dc_str.format(col_type, style=dc.style),
+            )
+
+        self.table.cursor_type = "none"

dataframe_textual/yes_no_screen.py

@@ -314,7 +314,7 @@ class SaveFileScreen(YesNoScreen):
         if self.input:
             input_filename = self.input.value.strip()
             if input_filename:
-                return input_filename, self.all_tabs
+                return input_filename, self.all_tabs, True  # Overwrite prompt
             else:
                 self.notify("Filename cannot be empty", title="Save", severity="error")
                 return None
@@ -359,7 +359,7 @@ class EditCellScreen(YesNoScreen):
 
         # Input
         df_value = df.item(ridx, cidx)
-        self.input_value = "" if df_value is None else str(df_value).strip()
+        self.input_value = NULL if df_value is None else str(df_value)
 
         super().__init__(
             title="Edit Cell",
@@ -373,20 +373,20 @@ class EditCellScreen(YesNoScreen):
 
     def _validate_input(self) -> None:
         """Validate and save the edited value."""
-        new_value_str = self.input.value.strip()
+        new_value_str = self.input.value  # Do not strip to preserve spaces
 
         # Handle empty input
         if not new_value_str:
-            new_value = None
+            new_value = ""
             self.notify(
-                "Empty value provided. If you want to clear the cell, press [$accent]x[/].",
-                title="Edit",
+                "Empty value provided. If you want to clear the cell, press [$accent]Delete[/].",
+                title="Edit Cell",
                 severity="warning",
             )
         # Check if value changed
         elif new_value_str == self.input_value:
             new_value = None
-            self.notify("No changes made", title="Edit", severity="warning")
+            self.notify("No changes made", title="Edit Cell", severity="warning")
         else:
             # Parse and validate based on column dtype
             try:
@@ -394,7 +394,7 @@ class EditCellScreen(YesNoScreen):
             except Exception as e:
                 self.notify(
                     f"Failed to convert [$accent]{new_value_str}[/] to [$error]{self.dtype}[/]: {str(e)}",
-                    title="Edit",
+                    title="Edit Cell",
                     severity="error",
                 )
                 return None
@@ -477,7 +477,7 @@ class SearchScreen(YesNoScreen):
 
     def _validate_input(self) -> tuple[str, int, bool, bool]:
         """Validate the input and return it."""
-        term = self.input.value.strip()
+        term = self.input.value  # Do not strip to preserve spaces
 
         if not term:
             self.notify("Term cannot be empty", title=self.title, severity="error")
@@ -508,7 +508,7 @@ class FilterScreen(YesNoScreen):
 
     def _get_input(self) -> tuple[str, int, bool, bool]:
         """Get input."""
-        term = self.input.value.strip()
+        term = self.input.value  # Do not strip to preserve spaces
         match_nocase = self.checkbox.value
         match_whole = self.checkbox2.value
 
@@ -590,7 +590,7 @@ class EditColumnScreen(YesNoScreen):
 
     def _get_input(self) -> tuple[str, int]:
         """Get input."""
-        term = self.input.value.strip()
+        term = self.input.value  # Do not strip to preserve spaces
         return term, self.cidx
 
 
@@ -606,19 +606,19 @@ class AddColumnScreen(YesNoScreen):
         self.existing_columns = set(df.columns)
         super().__init__(
             title="Add Column",
-            label="Enter column name",
-            input="Link" if link else "Column name",
-            label2="Enter link template, e.g., https://example.com/$_/id/$1, PC/compound/$cid"
+            label="Column name",
+            input="Link" if link else "Name",
+            label2="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",
+            else "Value or Polars expression, e.g., abc, pl.lit(123), NULL, $_ * 2, $1 + $total, $_ + '_suffix', $_.str.to_uppercase()",
+            input2="Link template" if link else "Value or expression",
             on_yes_callback=self._get_input,
         )
 
     def _get_input(self) -> tuple[int, str, str] | None:
         """Validate and return the new column configuration."""
         col_name = self.input.value.strip()
-        term = self.input2.value.strip()
+        term = self.input2.value  # Do not strip to preserve spaces
 
         # Validate column name
         if not col_name:
@@ -680,7 +680,11 @@ class FindReplaceScreen(YesNoScreen):
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "ReplaceScreen")
 
     def __init__(self, dftable: "DataFrameTable", title: str = "Find and Replace"):
-        term_find = str(dftable.cursor_value)
+        if (cursor_value := dftable.cursor_value) is None:
+            term_find = NULL
+        else:
+            term_find = str(cursor_value)
+
         super().__init__(
             title=title,
             label="Find",
@@ -698,8 +702,8 @@ class FindReplaceScreen(YesNoScreen):
 
     def _get_input(self) -> tuple[str, str, bool, bool, bool]:
         """Get input."""
-        term_find = self.input.value.strip()
-        term_replace = self.input2.value.strip()
+        term_find = self.input.value  # Do not strip to preserve spaces
+        term_replace = self.input2.value  # Do not strip to preserve spaces
         match_nocase = self.checkbox.value
         match_whole = self.checkbox2.value
         replace_all = False
@@ -708,8 +712,8 @@ class FindReplaceScreen(YesNoScreen):
 
     def _get_input_replace_all(self) -> tuple[str, str, bool, bool, bool]:
         """Get input for 'Replace All'."""
-        term_find = self.input.value.strip()
-        term_replace = self.input2.value.strip()
+        term_find = self.input.value  # Do not strip to preserve spaces
+        term_replace = self.input2.value  # Do not strip to preserve spaces
         match_nocase = self.checkbox.value
         match_whole = self.checkbox2.value
         replace_all = True