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

dataframe_textual/sql_screen.py

@@ -1,5 +1,6 @@
 """Modal screens for Polars sql manipulation"""
 
+from functools import partial
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -46,18 +47,20 @@ class SqlScreen(ModalScreen):
 
     """
 
-    def __init__(self, dftable: "DataFrameTable", on_yes_callback=None) -> None:
+    def __init__(self, dftable: "DataFrameTable", on_yes_callback=None, on_maybe_callback=None) -> None:
         """Initialize the SQL screen."""
         super().__init__()
         self.dftable = dftable  # DataFrameTable
         self.df: pl.DataFrame = dftable.df  # Polars DataFrame
         self.on_yes_callback = on_yes_callback
+        self.on_maybe_callback = on_maybe_callback
 
     def compose(self) -> ComposeResult:
         """Compose the SQL screen widget structure."""
         # Shared by subclasses
         with Horizontal(id="button-container"):
-            yield Button("Apply", id="yes", variant="success")
+            yield Button("View", id="yes", variant="success")
+            yield Button("Filter", id="maybe", variant="warning")
             yield Button("Cancel", id="no", variant="error")
 
     def on_key(self, event) -> None:
@@ -66,7 +69,16 @@ class SqlScreen(ModalScreen):
             self.app.pop_screen()
             event.stop()
         elif event.key == "enter":
-            self._handle_yes()
+            for button in self.query(Button):
+                if button.has_focus:
+                    if button.id == "yes":
+                        self._handle_yes()
+                    elif button.id == "maybe":
+                        self._handle_maybe()
+                    break
+            else:
+                self._handle_yes()
+
             event.stop()
         elif event.key == "escape":
             self.dismiss(None)
@@ -76,6 +88,8 @@ class SqlScreen(ModalScreen):
         """Handle button press events in the SQL screen."""
         if event.button.id == "yes":
             self._handle_yes()
+        elif event.button.id == "maybe":
+            self._handle_maybe()
         elif event.button.id == "no":
             self.dismiss(None)
 
@@ -87,6 +101,14 @@ class SqlScreen(ModalScreen):
         else:
             self.dismiss(True)
 
+    def _handle_maybe(self) -> None:
+        """Handle Maybe button press."""
+        if self.on_maybe_callback:
+            result = self.on_maybe_callback()
+            self.dismiss(result)
+        else:
+            self.dismiss(True)
+
 
 class SimpleSqlScreen(SqlScreen):
     """Simple SQL query screen."""
@@ -133,25 +155,38 @@ class SimpleSqlScreen(SqlScreen):
         Returns:
             None
         """
-        super().__init__(dftable, on_yes_callback=self._handle_simple)
+        super().__init__(
+            dftable,
+            on_yes_callback=self._handle_simple,
+            on_maybe_callback=partial(
+                self._handle_simple,
+                view=False,
+            ),
+        )
 
     def compose(self) -> ComposeResult:
         """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 SelectionList(*[Selection(col, col) for col in self.df.columns], id="column-selection")
+            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 Input(placeholder="e.g., age > 30 and height < 180", id="where-input")
             yield from super().compose()
 
-    def _handle_simple(self) -> None:
+    def _handle_simple(self, view: bool = True) -> None:
         """Handle Yes button/Enter key press."""
         selections = self.query_one(SelectionList).selected
-        columns = ", ".join(f"`{s}`" for s in selections) if selections else "*"
+        if not selections:
+            selections = [col for col in self.df.columns if col not in self.dftable.hidden_columns]
+
+        columns = ", ".join(f"`{s}`" for s in selections)
         where = self.query_one(Input).value.strip()
 
-        return columns, where
+        return columns, where, view
 
 
 class AdvancedSqlScreen(SqlScreen):
@@ -184,7 +219,11 @@ class AdvancedSqlScreen(SqlScreen):
         Returns:
             None
         """
-        super().__init__(dftable, on_yes_callback=self._handle_advanced)
+        super().__init__(
+            dftable,
+            on_yes_callback=self._handle_advanced,
+            on_maybe_callback=partial(self._handle_advanced, view=False),
+        )
 
     def compose(self) -> ComposeResult:
         """Compose the advanced SQL screen widget structure."""
@@ -197,6 +236,6 @@ class AdvancedSqlScreen(SqlScreen):
             )
             yield from super().compose()
 
-    def _handle_advanced(self) -> None:
+    def _handle_advanced(self, view: bool = True) -> None:
         """Handle Yes button/Enter key press."""
-        return self.query_one(TextArea).text.strip()
+        return self.query_one(TextArea).text.strip(), view

dataframe_textual/table_screen.py

@@ -144,7 +144,7 @@ class TableScreen(ModalScreen):
             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.setup_table()
 
         # Dismiss the frequency screen
         self.app.pop_screen()

dataframe_textual/yes_no_screen.py

@@ -5,11 +5,13 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from .data_frame_table import DataFrameTable
 
+
 import polars as pl
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal
 from textual.screen import ModalScreen
-from textual.widgets import Button, Checkbox, Input, Label, Static
+from textual.widgets import Button, Checkbox, Input, Label, Static, TabPane
+from textual.widgets.tabbed_content import ContentTab
 
 from .common import NULL, DtypeConfig, tentative_expr, validate_expr
 
@@ -254,7 +256,18 @@ class YesNoScreen(ModalScreen):
     def on_key(self, event) -> None:
         """Handle key press events in the table screen."""
         if event.key == "enter":
-            self._handle_yes()
+            for button in self.query(Button):
+                if button.has_focus:
+                    if button.id == "yes":
+                        self._handle_yes()
+                    elif button.id == "maybe":
+                        self._handle_maybe()
+                    elif button.id == "no":
+                        self.dismiss(None)
+                    break
+            else:
+                self._handle_yes()
+
             event.stop()
         elif event.key == "escape":
             self.dismiss(None)
@@ -282,18 +295,26 @@ class SaveFileScreen(YesNoScreen):
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "SaveFileScreen")
 
-    def __init__(self, filename: str, title="Save Tab"):
+    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)
         super().__init__(
             title=title,
+            label="Enter filename",
             input=filename,
+            yes="Save",
+            maybe="Save All Tabs" if self.all_tabs else None,
+            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
+                return input_filename, self.all_tabs
             else:
                 self.notify("Filename cannot be empty", title="Save", severity="error")
                 return None
@@ -578,16 +599,19 @@ class AddColumnScreen(YesNoScreen):
 
     CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "AddColumnScreen")
 
-    def __init__(self, cidx: int, df: pl.DataFrame):
+    def __init__(self, cidx: int, df: pl.DataFrame, link: bool = False):
         self.cidx = cidx
         self.df = df
+        self.link = link
         self.existing_columns = set(df.columns)
         super().__init__(
             title="Add Column",
             label="Enter column name",
-            input="column name",
-            label2="Enter value or Polars expression, e.g., abc, pl.lit(123), NULL, $_ * 2, $1 + $2, $_.str.to_uppercase(), pl.concat_str($_, pl.lit('-suffix'))",
-            input2="column value or expression",
+            input="Link" if link else "Column name",
+            label2="Enter 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",
             on_yes_callback=self._get_input,
         )
 
@@ -611,6 +635,9 @@ class AddColumnScreen(YesNoScreen):
 
         if term == NULL:
             return self.cidx, col_name, pl.lit(None)
+        elif self.link:
+            # Treat as link template
+            return self.cidx, col_name, term
         elif tentative_expr(term):
             try:
                 expr = validate_expr(term, self.df.columns, self.cidx)
@@ -633,6 +660,20 @@ class AddColumnScreen(YesNoScreen):
                 return self.cidx, col_name, pl.lit(term)
 
 
+class AddLinkScreen(AddColumnScreen):
+    """Modal screen to add a new link column with user-provided expressions.
+
+    Allows user to specify a column name and a value or Polars expression that will be
+    evaluated to create links. A new column is created with the resulting link values.
+    Inherits column name and expression validation from AddColumnScreen.
+    """
+
+    CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "AddLinkScreen")
+
+    def __init__(self, cidx: int, df: pl.DataFrame):
+        super().__init__(cidx, df, link=True)
+
+
 class FindReplaceScreen(YesNoScreen):
     """Modal screen to replace column values with an expression."""
 
@@ -674,3 +715,43 @@ class FindReplaceScreen(YesNoScreen):
         replace_all = True
 
         return term_find, term_replace, match_nocase, match_whole, replace_all
+
+
+class RenameTabScreen(YesNoScreen):
+    """Modal screen to rename a tab."""
+
+    CSS = YesNoScreen.DEFAULT_CSS.replace("YesNoScreen", "RenameTabScreen")
+
+    def __init__(self, content_tab: ContentTab, existing_tabs: list[TabPane]):
+        self.content_tab = content_tab
+        self.existing_tabs = existing_tabs
+        tab_name = content_tab.label_text
+
+        super().__init__(
+            title="Rename Tab",
+            label="New tab name",
+            input={"value": tab_name},
+            on_yes_callback=self._validate_input,
+        )
+
+    def _validate_input(self) -> None:
+        """Validate and save the new tab name."""
+        new_name = self.input.value.strip()
+
+        # Check if name is empty
+        if not new_name:
+            self.notify("Tab name cannot be empty", title="Rename Tab", severity="error")
+            return None
+
+        # Check if name changed
+        if new_name == self.content_tab.label_text:
+            self.notify("No changes made", title="Rename Tab", severity="warning")
+            return None
+
+        # Check if name already exists
+        if new_name in self.existing_tabs:
+            self.notify(f"Tab [$accent]{new_name}[/] already exists", title="Rename Tab", severity="error")
+            return None
+
+        # Return new name
+        return self.content_tab, new_name