dataframe-textual 1.12.0__py3-none-any.whl → 2.0.0__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 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"),  # '<'
@@ -243,7 +248,7 @@ class DataFrameViewer(App):
         Opens the save dialog for the active tab's DataFrameTable to save its data.
         """
         if table := self.get_active_table():
-            table.do_save_to_file(title="Save Current Tab", all_tabs=False)
+            table.do_save_to_file(all_tabs=False)
 
     def action_save_all_tabs(self) -> None:
         """Save all open tabs to their respective files.
@@ -251,7 +256,25 @@ class DataFrameViewer(App):
         Iterates through all DataFrameTable widgets and opens the save dialog for each.
         """
         if table := self.get_active_table():
-            table.do_save_to_file(title="Save All Tabs", all_tabs=True)
+            table.do_save_to_file(all_tabs=True)
+
+    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():
+            filepath = Path(table.filename)
+            filename = filepath.with_stem(table.tabname)
+            table.save_to_file((filename, False, False))
+
+    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():
+            filepath = Path(table.filename)
+            if filepath.suffix.lower() in [".xlsx", ".xls"]:
+                filename = table.filename
+            else:
+                filename = "all-tabs.xlsx"
+
+            table.save_to_file((filename, True, False))
 
     def action_duplicate_tab(self) -> None:
         """Duplicate the currently active tab.
@@ -269,7 +292,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

@@ -13,6 +13,8 @@ from textual.screen import ModalScreen
 from textual.widgets import Button, Input, Label, SelectionList, TextArea
 from textual.widgets.selection_list import Selection
 
+from .common import RID
+
 
 class SqlScreen(ModalScreen):
     """Base class for modal screens handling SQL query."""
@@ -151,9 +153,6 @@ class SimpleSqlScreen(SqlScreen):
 
         Args:
             dftable: Reference to the parent DataFrameTable widget.
-
-        Returns:
-            None
         """
         super().__init__(
             dftable,
@@ -165,12 +164,16 @@ 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],
+                *[
+                    Selection(col, col)
+                    for col in self.df.columns
+                    if col not in self.dftable.hidden_columns and col != RID
+                ],
                 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()
 
@@ -178,7 +181,7 @@ class SimpleSqlScreen(SqlScreen):
         """Handle Yes button/Enter key press."""
         selections = self.query_one(SelectionList).selected
         if not selections:
-            selections = [col for col in self.df.columns if col not in self.dftable.hidden_columns]
+            selections = [col for col in self.df.columns if col not in self.dftable.hidden_columns and col != RID]
 
         columns = ", ".join(f"`{s}`" for s in selections)
         where = self.query_one(Input).value.strip()
@@ -212,9 +215,6 @@ class AdvancedSqlScreen(SqlScreen):
 
         Args:
             dftable: Reference to the parent DataFrameTable widget.
-
-        Returns:
-            None
         """
         super().__init__(
             dftable,
@@ -227,7 +227,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, 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()
@@ -111,7 +102,7 @@ class TableScreen(ModalScreen):
         if cidx_name_value is None:
             return
         cidx, col_name, col_value = cidx_name_value
-        self.log(f"Filtering or viewing by {col_name} == {col_value}")
+        self.log(f"Filtering or viewing by `{col_name} == {col_value}`")
 
         # Handle NULL values
         if col_value == NULL:
@@ -123,11 +114,11 @@ class TableScreen(ModalScreen):
             expr = pl.col(col_name) == col_value
             value_display = f"[$success]{col_value}[/]"
 
-        df_filtered = self.dftable.df.with_row_index(RIDX).filter(expr)
+        df_filtered = self.dftable.df.lazy().filter(expr).collect()
         self.log(f"Filtered dataframe has {len(df_filtered)} rows")
 
-        matched_indices = set(df_filtered[RIDX].to_list())
-        if not matched_indices:
+        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",
@@ -135,18 +126,12 @@ class TableScreen(ModalScreen):
             )
             return
 
-        # Apply the action
+        # Action filter
         if action == "filter":
-            # Update selections
-            for i in range(len(self.dftable.selected_rows)):
-                self.dftable.selected_rows[i] = i in matched_indices
-
-            # 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))]
+        # Action view
+        else:
             self.dftable.view_rows((expr, cidx, False, True))
 
         # Dismiss the frequency screen
@@ -167,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()
 
@@ -181,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 == 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"
 
@@ -209,7 +191,21 @@ 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 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_cidx_name_value(self) -> tuple[int, str, Any] | None:
@@ -254,12 +250,8 @@ class StatisticsScreen(TableScreen):
         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
 
@@ -275,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:
         """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):
@@ -329,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)
 
@@ -352,13 +320,11 @@ class FrequencyScreen(TableScreen):
     def __init__(self, cidx: int, dftable: "DataFrameTable") -> None:
         super().__init__(dftable)
         self.cidx = cidx
-        self.sorted_columns = {
-            1: True,  # Count
-        }
+        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.cidx]].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."""
@@ -412,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,
@@ -455,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",
             ),
@@ -503,3 +454,74 @@ 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 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"

dataframe_textual/yes_no_screen.py

@@ -119,9 +119,6 @@ class YesNoScreen(ModalScreen):
             maybe: Optional Maybe button text/dict. Defaults to None.
             no: Text or dict for the No button. If None, hides the No button. Defaults to "No".
             on_yes_callback: Optional callable that takes no args and returns the value to dismiss with when Yes is pressed. Defaults to None.
-
-        Returns:
-            None
         """
         super().__init__()
         self.title = title
@@ -295,32 +292,26 @@ class SaveFileScreen(YesNoScreen):
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "SaveFileScreen")
 
-    def __init__(
-        self, filename: str, title: str = "Save to File", all_tabs: bool | None = None, multi_tab: bool = False
-    ):
-        self.all_tabs = all_tabs or (all_tabs is None and multi_tab)
+    def __init__(self, filename: str, save_all: bool = False, tab_count: int = 1):
+        self.save_all = save_all
         super().__init__(
-            title=title,
-            label="Enter filename",
+            title="Save to File",
+            label="Filename",
             input=filename,
-            yes="Save",
-            maybe="Save All Tabs" if self.all_tabs else None,
+            yes=f"Save {tab_count} Tabs" if self.save_all else "Save Current Tab" if tab_count > 1 else "Save",
             no="Cancel",
             on_yes_callback=self.handle_save,
-            on_maybe_callback=self.handle_save,
         )
 
     def handle_save(self):
         if self.input:
             input_filename = self.input.value.strip()
             if input_filename:
-                return input_filename, self.all_tabs
+                return input_filename, self.save_all, True  # Overwrite prompt
             else:
                 self.notify("Filename cannot be empty", title="Save", severity="error")
                 return None
 
-        return None
-
 
 class ConfirmScreen(YesNoScreen):
     """Modal screen to ask for confirmation."""
@@ -359,7 +350,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 +364,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 +385,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 +468,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 +499,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
 
@@ -583,14 +574,14 @@ class EditColumnScreen(YesNoScreen):
         self.df = df
         super().__init__(
             title="Edit Column",
-            label=f"by value or Polars expression, e.g., abc, pl.lit(7), {NULL}, $_ * 2, $1 + $2, $_.str.to_uppercase(), pl.arange(0, pl.len())",
+            label=f"By value or Polars expression, e.g., abc, pl.lit(7), {NULL}, $_ * 2, $1 + $2, $_.str.to_uppercase(), pl.arange(0, pl.len())",
             input="$_",
             on_yes_callback=self._get_input,
         )
 
     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 +597,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 "New column",
+            label2="Link template, e.g., https://example.com/$1/id/$_, 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 +671,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 +693,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 +703,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