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

dataframe_textual/data_frame_viewer.py

@@ -1,21 +1,21 @@
 """DataFrame Viewer application and utilities."""
 
 import os
-from functools import partial
 from pathlib import Path
 from textwrap import dedent
 
 import polars as pl
 from textual.app import App, ComposeResult
 from textual.css.query import NoMatches
+from textual.events import Click
 from textual.theme import BUILTIN_THEMES
 from textual.widgets import TabbedContent, TabPane
-from textual.widgets.tabbed_content import ContentTabs
+from textual.widgets.tabbed_content import ContentTab, ContentTabs
 
-from .common import get_next_item, load_file
+from .common import Source, get_next_item, load_file
 from .data_frame_help_panel import DataFrameHelpPanel
 from .data_frame_table import DataFrameTable
-from .yes_no_screen import OpenFileScreen, SaveFileScreen
+from .yes_no_screen import ConfirmScreen, OpenFileScreen, RenameTabScreen
 
 
 class DataFrameViewer(App):
@@ -25,13 +25,18 @@ class DataFrameViewer(App):
         # 📊 DataFrame Viewer - App Controls
 
         ## 🎯 File & Tab Management
-        - **Ctrl+O** - 📁 Add a new tab
-        - **Ctrl+A** - 💾 Save all tabs
-        - **Ctrl+W** - ❌ Close current tab
-        - **>** or **b** - ▶️ Next tab
+        - **>** - ▶️ Next tab
         - **<** - ◀️ Previous tab
+        - **b** - 🔄 Cycle through tabs
         - **B** - 👁️ Toggle tab bar visibility
-        - **q** - 🚪 Quit application
+        - **q** - ❌ Close current tab (prompts to save unsaved changes)
+        - **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
+        - **Ctrl+A** - 💾 Save all tabs to file
+        - **Ctrl+D** - 📋 Duplicate current tab
+        - **Ctrl+O** - 📁 Open a file
+        - **Double-click tab** - ✏️ Rename current tab
 
         ## 🎨 View & Settings
         - **F1** - ❓ Toggle this help panel
@@ -39,25 +44,27 @@ class DataFrameViewer(App):
 
         ## ⭐ Features
         - **Multi-file support** - 📂 Open multiple CSV/Excel files as tabs
-        - **Excel sheets** - 📊 Excel files auto-expand sheets into tabs
         - **Lazy loading** - ⚡ Large files load on demand
         - **Sticky tabs** - 📌 Tab bar stays visible when scrolling
+        - **Unsaved changes** - 🔴 Tabs with unsaved changes have a bright bottom border
         - **Rich formatting** - 🎨 Color-coded data types
         - **Search & filter** - 🔍 Find and filter data quickly
-        - **Sort & reorder** - ⬆️ Multi-column sort, drag rows/columns
-        - **Undo/Redo** - 🔄 Full history of operations
+        - **Sort & reorder** - ⬆️ Multi-column sort, reorder rows/columns
+        - **Undo/Redo/Reset** - 🔄 Full history of operations
         - **Freeze rows/cols** - 🔒 Pin header rows and columns
     """).strip()
 
     BINDINGS = [
-        ("q", "quit", "Quit"),
-        ("f1", "toggle_help_panel", "Help"),
+        ("q", "close_tab", "Close current tab"),
+        ("Q", "close_all_tabs", "Close all tabs and quit app"),
         ("B", "toggle_tab_bar", "Toggle Tab Bar"),
-        ("ctrl+o", "add_tab", "Add Tab"),
+        ("f1", "toggle_help_panel", "Help"),
+        ("ctrl+o", "open_file", "Open File"),
+        ("ctrl+t", "save_current_tab", "Save Current Tab"),
         ("ctrl+a", "save_all_tabs", "Save All Tabs"),
-        ("ctrl+w", "close_tab", "Close Tab"),
-        ("greater_than_sign,b", "next_tab(1)", "Next Tab"),
-        ("less_than_sign", "next_tab(-1)", "Prev Tab"),
+        ("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"),  # '<'
     ]
 
     CSS = """
@@ -71,9 +78,16 @@ class DataFrameViewer(App):
         ContentTab.-active {
             background: $block-cursor-background; /* Same as underline */
         }
+        ContentTab.dirty {
+            background: $warning-darken-3;
+        }
+
+        .underline--bar {
+            color: red;
+        }
     """
 
-    def __init__(self, *sources: str) -> None:
+    def __init__(self, *sources: Source) -> None:
         """Initialize the DataFrame Viewer application.
 
         Loads data from provided sources and prepares the tabbed interface.
@@ -81,9 +95,6 @@ class DataFrameViewer(App):
         Args:
             sources: sources to load dataframes from, each as a tuple of
                      (DataFrame, filename, tabname).
-
-        Returns:
-            None
         """
         super().__init__()
         self.sources = sources
@@ -103,8 +114,9 @@ class DataFrameViewer(App):
         self.tabbed = TabbedContent(id="main_tabs")
         with self.tabbed:
             seen_names = set()
-            for idx, (df, filename, tabname) in enumerate(self.sources, start=1):
-                tab_id = f"tab_{idx}"
+            for idx, source in enumerate(self.sources, start=1):
+                df, filename, tabname = source.frame, source.filename, source.tabname
+                tab_id = f"tab-{idx}"
 
                 if not tabname:
                     tabname = Path(filename).stem or tab_id
@@ -117,8 +129,8 @@ class DataFrameViewer(App):
                 seen_names.add(tabname)
 
                 try:
-                    table = DataFrameTable(df, filename, name=tabname, id=tab_id, zebra_stripes=True)
-                    tab = TabPane(tabname, table, name=tabname, id=tab_id)
+                    table = DataFrameTable(df, filename, tabname=tabname, id=tab_id, zebra_stripes=True)
+                    tab = TabPane(tabname, table, id=tab_id)
                     self.tabs[tab] = table
                     yield tab
                 except Exception as e:
@@ -133,13 +145,15 @@ class DataFrameViewer(App):
 
         Initializes the app by hiding the tab bar for single-file mode and focusing
         the active table widget.
-
-        Returns:
-            None
         """
         if len(self.tabs) == 1:
             self.query_one(ContentTabs).display = False
-            self._get_active_table().focus()
+            self.get_active_table().focus()
+
+    def on_ready(self) -> None:
+        """Called when the app is ready."""
+        # self.log(self.tree)
+        pass
 
     def on_key(self, event) -> None:
         """Handle key press events at the application level.
@@ -148,14 +162,32 @@ class DataFrameViewer(App):
 
         Args:
             event: The key event object containing key information.
-
-        Returns:
-            None
         """
         if event.key == "k":
             self.theme = get_next_item(list(BUILTIN_THEMES.keys()), self.theme)
             self.notify(f"Switched to theme: [$success]{self.theme}[/]", title="Theme")
 
+    def on_click(self, event: Click) -> None:
+        """Handle mouse click events on tabs.
+
+        Detects double-clicks on tab headers and opens the rename screen.
+
+        Args:
+            event: The click event containing position information.
+        """
+        # Check if this is a double-click (chain > 1) on a tab header
+        if event.chain > 1:
+            try:
+                # Get the widget that was clicked
+                content_tab = event.widget
+
+                # Check if it's a ContentTab (tab header)
+                if isinstance(content_tab, ContentTab):
+                    self.do_rename_tab(content_tab)
+            except Exception as e:
+                self.log(f"Error handling tab rename click: {str(e)}")
+                pass
+
     def on_tabbed_content_tab_activated(self, event: TabbedContent.TabActivated) -> None:
         """Handle tab activation events.
 
@@ -164,26 +196,20 @@ class DataFrameViewer(App):
 
         Args:
             event: The tab activated event containing the activated tab pane.
-
-        Returns:
-            None
         """
         # Focus the table in the newly activated tab
-        if table := self._get_active_table():
+        if table := self.get_active_table():
             table.focus()
         else:
             return
 
         if table.loaded_rows == 0:
-            table._setup_table()
+            table.setup_table()
 
     def action_toggle_help_panel(self) -> None:
         """Toggle the help panel on or off.
 
         Shows or hides the context-sensitive help panel. Creates it on first use.
-
-        Returns:
-            None
         """
         if self.help_panel:
             self.help_panel.display = not self.help_panel.display
@@ -191,44 +217,83 @@ class DataFrameViewer(App):
             self.help_panel = DataFrameHelpPanel()
             self.mount(self.help_panel)
 
-    def action_add_tab(self) -> None:
+    def action_open_file(self) -> None:
         """Open file browser to load a file in a new tab.
 
         Displays the file open dialog for the user to select a file to load
         as a new tab in the interface.
+        """
+        self.push_screen(OpenFileScreen(), self.do_open_file)
 
-        Returns:
-            None
+    def action_close_tab(self) -> None:
+        """Close the current tab.
+
+        Checks for unsaved changes and prompts the user to save if needed.
+        If this is the last tab, exits the app.
         """
-        self.push_screen(OpenFileScreen(), self._do_add_tab)
+        self.do_close_tab()
 
-    def action_save_all_tabs(self) -> None:
-        """Save all open tabs to a single Excel file.
+    def action_close_all_tabs(self) -> None:
+        """Close all tabs and exit the app.
 
-        Displays a save dialog to choose filename and location, then saves all
-        open tabs as separate sheets in a single Excel workbook.
+        Checks if any tabs have unsaved changes. If yes, opens a confirmation dialog.
+        Otherwise, quits immediately.
+        """
+        self.do_close_all_tabs()
 
-        Returns:
-            None
+    def action_save_current_tab(self) -> None:
+        """Save the currently active tab to file.
+
+        Opens the save dialog for the active tab's DataFrameTable to save its data.
         """
-        callback = partial(self._get_active_table()._do_save_file, all_tabs=True)
-        self.push_screen(
-            SaveFileScreen("all-tabs.xlsx", title="Save All Tabs"),
-            callback=callback,
-        )
+        if table := self.get_active_table():
+            table.do_save_to_file(title="Save Current Tab", all_tabs=False)
 
-    def action_close_tab(self) -> None:
-        """Close the currently active tab.
+    def action_save_all_tabs(self) -> None:
+        """Save all open tabs to their respective files.
 
-        Closes the current tab. If this is the only tab, exits the application instead.
+        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)
 
-        Returns:
-            None
+    def action_duplicate_tab(self) -> None:
+        """Duplicate the currently active tab.
+
+        Creates a copy of the current tab with the same data and filename.
+        The new tab is named with '_copy' suffix and inserted after the current tab.
         """
-        if len(self.tabs) <= 1:
-            self.app.exit()
+        if not (table := self.get_active_table()):
             return
-        self._close_tab()
+
+        # Get current tab info
+        current_tabname = table.tabname
+        new_tabname = f"{current_tabname}_copy"
+        new_tabname = self.get_unique_tabname(new_tabname)
+
+        # Create new table with the same dataframe and filename
+        new_table = DataFrameTable(
+            table.df,
+            table.filename,
+            tabname=new_tabname,
+            zebra_stripes=True,
+            id=f"tab-{len(self.tabs) + 1}",
+        )
+        new_pane = TabPane(new_tabname, new_table, id=new_table.id)
+
+        # Add the new tab
+        active_pane = self.tabbed.active_pane
+        self.tabbed.add_pane(new_pane, after=active_pane)
+        self.tabs[new_pane] = new_table
+
+        # Show tab bar if needed
+        if len(self.tabs) > 1:
+            self.query_one(ContentTabs).display = True
+
+        # Activate and focus the new tab
+        self.tabbed.active = new_pane.id
+        new_table.focus()
+        new_table.dirty = True  # Mark as dirty since it's a new unsaved tab
 
     def action_next_tab(self, offset: int = 1) -> None:
         """Switch to the next tab or previous tab.
@@ -238,9 +303,6 @@ class DataFrameViewer(App):
 
         Args:
             offset: Number of tabs to advance (+1 for next, -1 for previous). Defaults to 1.
-
-        Returns:
-            None
         """
         if len(self.tabs) <= 1:
             return
@@ -256,16 +318,13 @@ class DataFrameViewer(App):
 
         Shows or hides the tab bar at the bottom of the window. Useful for maximizing
         screen space in single-tab mode.
-
-        Returns:
-            None
         """
         tabs = self.query_one(ContentTabs)
         tabs.display = not tabs.display
         # status = "shown" if tabs.display else "hidden"
         # self.notify(f"Tab bar [$success]{status}[/]", title="Toggle")
 
-    def _get_active_table(self) -> DataFrameTable | None:
+    def get_active_table(self) -> DataFrameTable | None:
         """Get the currently active DataFrameTable widget.
 
         Retrieves the table from the currently active tab. Returns None if no
@@ -282,23 +341,40 @@ class DataFrameViewer(App):
             self.notify("No active table found", title="Locate", severity="error")
         return None
 
-    def _do_add_tab(self, filename: str) -> None:
-        """Add a tab for the opened file.
+    def get_unique_tabname(self, tab_name: str) -> str:
+        """Generate a unique tab name based on the given base name.
+
+        If the base name already exists among current tabs, appends an index
+        to make it unique.
+
+        Args:
+            tab_name: The desired base name for the tab.
+
+        Returns:
+            A unique tab name.
+        """
+        tabname = tab_name
+        counter = 1
+        while any(table.tabname == tabname for table in self.tabs.values()):
+            tabname = f"{tab_name}_{counter}"
+            counter += 1
+
+        return tabname
+
+    def do_open_file(self, filename: str) -> None:
+        """Open a file.
 
         Loads the specified file and creates one or more tabs for it. For Excel files,
         creates one tab per sheet. For other formats, creates a single tab.
 
         Args:
             filename: Path to the file to load and add as tab(s).
-
-        Returns:
-            None
         """
         if filename and os.path.exists(filename):
             try:
                 n_tab = 0
-                for lf, filename, tabname in load_file(filename, prefix_sheet=True):
-                    self._add_tab(lf, filename, tabname)
+                for source in load_file(filename, prefix_sheet=True):
+                    self.add_tab(source.frame, filename, source.tabname, after=self.tabbed.active_pane)
                     n_tab += 1
                 # self.notify(f"Added [$accent]{n_tab}[/] tab(s) for [$success]{filename}[/]", title="Open")
             except Exception as e:
@@ -306,7 +382,14 @@ class DataFrameViewer(App):
         else:
             self.notify(f"File does not exist: [$warning]{filename}[/]", title="Open", severity="warning")
 
-    def _add_tab(self, df: pl.DataFrame, filename: str, tabname: str) -> None:
+    def add_tab(
+        self,
+        df: pl.DataFrame,
+        filename: str,
+        tabname: str,
+        before: TabPane | str | None = None,
+        after: TabPane | str | None = None,
+    ) -> None:
         """Add new tab for the given DataFrame.
 
         Creates and adds a new tab with the provided DataFrame and configuration.
@@ -317,30 +400,40 @@ class DataFrameViewer(App):
             lf: The Polars DataFrame to display in the new tab.
             filename: The source filename for this data (used in table metadata).
             tabname: The display name for the tab.
-
-        Returns:
-            None
         """
-        # Ensure unique tab names
-        counter = 1
-        while any(tab.name == tabname for tab in self.tabs):
-            tabname = f"{tabname}_{counter}"
-            counter += 1
+        tabname = self.get_unique_tabname(tabname)
 
         # Find an available tab index
-        tab_idx = f"tab_{len(self.tabs) + 1}"
+        tab_idx = f"tab-{len(self.tabs) + 1}"
         for idx in range(len(self.tabs)):
-            pending_tab_idx = f"tab_{idx + 1}"
+            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
+        table = DataFrameTable(df, filename, tabname=tabname, zebra_stripes=True, id=tab_idx)
+        tab = TabPane(tabname, table, id=tab_idx)
+        self.tabbed.add_pane(tab, before=before, after=after)
+
+        # Insert tab at specified position
+        tabs = list(self.tabs.keys())
+
+        if before and (idx := tabs.index(before)) != -1:
+            self.tabs = {
+                **{tab: self.tabs[tab] for tab in tabs[:idx]},
+                tab: table,
+                **{tab: self.tabs[tab] for tab in tabs[idx:]},
+            }
+        elif after and (idx := tabs.index(after)) != -1:
+            self.tabs = {
+                **{tab: self.tabs[tab] for tab in tabs[: idx + 1]},
+                tab: table,
+                **{tab: self.tabs[tab] for tab in tabs[idx + 1 :]},
+            }
+        else:
+            self.tabs[tab] = table
 
         if len(self.tabs) > 1:
             self.query_one(ContentTabs).display = True
@@ -349,22 +442,146 @@ class DataFrameViewer(App):
         self.tabbed.active = tab.id
         table.focus()
 
-    def _close_tab(self) -> None:
+    def do_close_tab(self) -> None:
         """Close the currently active tab.
 
         Removes the active tab from the interface. If only one tab remains and no more
         can be closed, the application exits instead.
-
-        Returns:
-            None
         """
         try:
-            if len(self.tabs) == 1:
-                self.app.exit()
+            if not (active_pane := self.tabbed.active_pane):
+                return
+
+            if not (active_table := self.tabs.get(active_pane)):
+                return
+
+            def _on_save_confirm(result: bool) -> None:
+                """Handle the "save before closing?" confirmation."""
+                if result:
+                    # User wants to save - close after save dialog opens
+                    active_table.do_save_to_file(title="Save Current Tab", task_after_save="close_tab")
+                elif result is None:
+                    # User cancelled - do nothing
+                    return
+                else:
+                    # User wants to discard - close immediately
+                    self.close_tab()
+
+            if active_table.dirty:
+                self.push_screen(
+                    ConfirmScreen(
+                        "Close Tab",
+                        label="This tab has unsaved changes. Save changes?",
+                        yes="Save",
+                        maybe="Discard",
+                        no="Cancel",
+                    ),
+                    callback=_on_save_confirm,
+                )
             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 [$success]{active_pane.name}[/]", title="Close")
-        except NoMatches:
+                # No unsaved changes - close immediately
+                self.close_tab()
+        except Exception:
+            pass
+
+    def close_tab(self) -> None:
+        """Actually close the tab."""
+        try:
+            if not (active_pane := self.tabbed.active_pane):
+                return
+
+            self.tabbed.remove_pane(active_pane.id)
+            self.tabs.pop(active_pane)
+
+            # Quit app if no tabs remain
+            if len(self.tabs) == 0:
+                self.exit()
+        except Exception:
+            pass
+
+    def do_close_all_tabs(self) -> None:
+        """Close all tabs and quit the app.
+
+        Checks if any tabs have unsaved changes. If yes, opens a confirmation dialog.
+        Otherwise, quits immediately.
+        """
+        try:
+            # Check for dirty tabs
+            dirty_tabnames = [table.tabname for table in self.tabs.values() if table.dirty]
+            if not dirty_tabnames:
+                self.exit()
+                return
+
+            def _save_and_quit(result: bool) -> None:
+                if result:
+                    self.get_active_table()._save_to_file(task_after_save="quit_app")
+                elif result is None:
+                    # User cancelled - do nothing
+                    return
+                else:
+                    # User wants to discard - quit immediately
+                    self.exit()
+
+            tab_list = "\n".join(f"  - [$warning]{name}[/]" for name in dirty_tabnames)
+            label = (
+                f"The following tabs have unsaved changes:\n\n{tab_list}\n\nSave all changes?"
+                if len(dirty_tabnames) > 1
+                else f"The tab [$warning]{dirty_tabnames[0]}[/] has unsaved changes.\n\nSave changes?"
+            )
+            self.push_screen(
+                ConfirmScreen(
+                    "Close All Tabs",
+                    label=label,
+                    yes="Save",
+                    maybe="Discard",
+                    no="Cancel",
+                ),
+                callback=_save_and_quit,
+            )
+
+        except Exception as e:
+            self.log(f"Error quitting all tabs: {str(e)}")
             pass
+
+    def do_rename_tab(self, content_tab: ContentTab) -> None:
+        """Open the rename tab screen.
+
+        Allows the user to rename the current tab and updates the table name accordingly.
+
+        Args:
+            content_tab: The ContentTab to rename.
+        """
+        if content_tab is None:
+            return
+
+        # Get list of existing tab names (excluding current tab)
+        existing_tabs = self.tabs.keys()
+
+        # Push the rename screen
+        self.push_screen(
+            RenameTabScreen(content_tab, existing_tabs),
+            callback=self.rename_tab,
+        )
+
+    def rename_tab(self, result) -> None:
+        """Handle result from RenameTabScreen."""
+        if result is None:
+            return
+
+        content_tab: ContentTab
+        content_tab, new_name = result
+
+        # Update the tab name
+        old_name = content_tab.label_text
+        content_tab.label = new_name
+
+        # Mark tab as dirty to indicate name change
+        tab_id = content_tab.id.removeprefix("--content-tab-")
+        for tab, table in self.tabs.items():
+            if tab.id == tab_id:
+                table.tabname = new_name
+                table.dirty = True
+                table.focus()
+                break
+
+        self.notify(f"Renamed tab [$accent]{old_name}[/] to [$success]{new_name}[/]", title="Rename")