dataframe-textual 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

dataframe_textual/data_frame_viewer.py

@@ -0,0 +1,320 @@
+"""DataFrame Viewer application and utilities."""
+
+import os
+import sys
+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.theme import BUILTIN_THEMES
+from textual.widgets import TabbedContent, TabPane
+from textual.widgets.tabbed_content import ContentTab, ContentTabs
+
+from .common import _next
+from .data_frame_help_panel import DataFrameHelpPanel
+from .data_frame_table import DataFrameTable
+from .yes_no_screen import OpenFileScreen, SaveFileScreen
+
+
+class DataFrameViewer(App):
+    """A Textual app to interact with multiple Polars DataFrames via tabbed interface."""
+
+    HELP = dedent("""
+        # 📊 DataFrame Viewer - App Controls
+
+        ## 🎯 File & Tab Management
+        - **Ctrl+O** - 📁 Add a new tab
+        - **Ctrl+Shift+S** - 💾 Save all tabs
+        - **Ctrl+W** - ❌ Close current tab
+        - **>** or **b** - ▶️ Next tab
+        - **<** - ◀️ Previous tab
+        - **B** - 👁️ Toggle tab bar visibility
+        - **q** - 🚪 Quit application
+
+        ## 🎨 View & Settings
+        - **?** or **h** - ❓ Toggle this help panel
+        - **k** - 🌙 Cycle through themes
+
+        ## ⭐ 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
+        - **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
+        - **Freeze rows/cols** - 🔒 Pin header rows and columns
+    """).strip()
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("h,?", "toggle_help_panel", "Help"),
+        ("B", "toggle_tab_bar", "Toggle Tab Bar"),
+        ("ctrl+o", "add_tab", "Add Tab"),
+        ("ctrl+shift+s", "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"),
+    ]
+
+    CSS = """
+        TabbedContent {
+            height: 100%;  /* Or a specific value, e.g., 20; */
+        }
+        TabbedContent > ContentTabs {
+            dock: bottom;
+        }
+        TabbedContent > ContentSwitcher {
+            overflow: auto;
+            height: 1fr;  /* Takes the remaining space below tabs */
+        }
+
+        TabbedContent ContentTab.active {
+            background: $primary;
+            color: $text;
+        }
+    """
+
+    def __init__(self, *filenames):
+        super().__init__()
+        self.sources = _load_dataframe(filenames)
+        self.tabs: dict[TabPane, DataFrameTable] = {}
+        self.help_panel = None
+
+    def compose(self) -> ComposeResult:
+        """Create tabbed interface for multiple files or direct table for single file."""
+        # Tabbed interface
+        self.tabbed = TabbedContent(id="main_tabs")
+        with self.tabbed:
+            seen_names = set()
+            for idx, (df, filename, tabname) in enumerate(self.sources, start=1):
+                # Ensure unique tab names
+                if tabname in seen_names:
+                    tabname = f"{tabname}_{idx}"
+                seen_names.add(tabname)
+
+                tab_id = f"tab_{idx}"
+                try:
+                    table = DataFrameTable(
+                        df, filename, name=tabname, id=tab_id, zebra_stripes=True
+                    )
+                    tab = TabPane(tabname, table, name=tabname, id=tab_id)
+                    self.tabs[tab] = table
+                    yield tab
+                except Exception as e:
+                    self.notify(f"Error loading {tabname}: {e}", severity="error")
+
+    def on_mount(self) -> None:
+        """Set up the app when it starts."""
+        if len(self.tabs) == 1:
+            self.query_one(ContentTabs).display = False
+            self._get_active_table().focus()
+
+    def on_key(self, event):
+        if event.key == "k":
+            self.theme = _next(list(BUILTIN_THEMES.keys()), self.theme)
+            self.notify(f"Switched to theme: [$primary]{self.theme}[/]", title="Theme")
+
+    def on_tabbed_content_tab_activated(
+        self, event: TabbedContent.TabActivated
+    ) -> None:
+        """Handle tab changes (only for multiple tabs)."""
+        # Only process if we have multiple files
+        if len(self.tabs) <= 1:
+            return
+
+        # Apply background color to active tab
+        event.tab.add_class("active")
+        for tab in self.tabbed.query(ContentTab):
+            if tab != event.tab:
+                tab.remove_class("active")
+
+        try:
+            # Focus the table in the newly activated tab
+            if table := self._get_active_table():
+                table.focus()
+        except NoMatches:
+            pass
+
+    def _get_active_table(self) -> DataFrameTable | None:
+        """Get the currently active table."""
+        try:
+            tabbed: TabbedContent = self.query_one(TabbedContent)
+            if active_pane := tabbed.active_pane:
+                return active_pane.query_one(DataFrameTable)
+        except (NoMatches, AttributeError):
+            pass
+        return None
+
+    def action_toggle_help_panel(self) -> None:
+        """Toggle the HelpPanel on/off."""
+        if self.help_panel:
+            self.help_panel.display = not self.help_panel.display
+        else:
+            self.help_panel = DataFrameHelpPanel()
+            self.mount(self.help_panel)
+
+    def action_add_tab(self) -> None:
+        """Open file dialog to load file to new tab."""
+        self.push_screen(OpenFileScreen(), self._handle_file_open)
+
+    def _handle_file_open(self, filename: str) -> None:
+        """Handle file selection from dialog."""
+        if filename and os.path.exists(filename):
+            try:
+                df = pl.read_csv(filename)
+                self._add_tab(df, filename)
+                self.notify(
+                    f"Opened: [on $primary]{Path(filename).name}[/]", title="Open"
+                )
+            except Exception as e:
+                self.notify(f"Error: {e}", severity="error")
+
+    def action_save_all_tabs(self) -> None:
+        """Save all tabs to a Excel file."""
+        callback = partial(self._get_active_table()._on_save_file_screen, all_tabs=True)
+        self.push_screen(
+            SaveFileScreen("all-tabs.xlsx", title="Save All Tabs"),
+            callback=callback,
+        )
+
+    def action_close_tab(self) -> None:
+        """Close current tab (only for multiple files)."""
+        if len(self.tabs) <= 1:
+            self.app.exit()
+            return
+        self._close_tab()
+
+    def action_next_tab(self, offset: int = 1) -> str:
+        """Switch to next tab (only for multiple files)."""
+        if len(self.tabs) <= 1:
+            return
+        try:
+            tabs: list[TabPane] = list(self.tabs.keys())
+            next_tab = _next(tabs, self.tabbed.active_pane, offset)
+            self.tabbed.active = next_tab.id
+        except (NoMatches, ValueError):
+            pass
+
+    def _add_tab(self, df: pl.DataFrame, filename: str) -> None:
+        """Add new table tab. If single file, replace table; if multiple, add tab."""
+        table = DataFrameTable(df, filename, zebra_stripes=True)
+        tabname = Path(filename).stem
+        if any(tab.name == tabname for tab in self.tabs):
+            tabname = f"{tabname}_{len(self.tabs) + 1}"
+
+        tab = TabPane(tabname, table, name=tabname, id=f"tab_{len(self.tabs) + 1}")
+        self.tabbed.add_pane(tab)
+        self.tabs[tab] = table
+
+        if len(self.tabs) > 1:
+            self.query_one(ContentTabs).display = True
+
+        # Activate the new tab
+        self.tabbed.active = tab.id
+        table.focus()
+
+    def _close_tab(self) -> None:
+        """Close current tab."""
+        try:
+            if len(self.tabs) == 1:
+                self.app.exit()
+            else:
+                if active_pane := self.tabbed.active_pane:
+                    self.tabbed.remove_pane(active_pane.id)
+                    self.notify(
+                        f"Closed tab [on $primary]{active_pane.name}[/]", title="Close"
+                    )
+        except NoMatches:
+            pass
+
+    def action_toggle_tab_bar(self) -> None:
+        """Toggle tab bar visibility."""
+        tabs = self.query_one(ContentTabs)
+        tabs.display = not tabs.display
+        status = "shown" if tabs.display else "hidden"
+        self.notify(f"Tab bar [on $primary]{status}[/]", title="Toggle")
+
+
+def _load_dataframe(filenames: list[str]) -> list[tuple[pl.DataFrame, str, str]]:
+    """Load a DataFrame from a file spec.
+
+    Args:
+        filenames: List of filenames to load. If single filename is "-", read from stdin.
+
+    Returns:
+        List of tuples of (DataFrame, filename, tabname)
+    """
+    sources = []
+
+    # Single file
+    if len(filenames) == 1:
+        filename = filenames[0]
+        filepath = Path(filename)
+        ext = filepath.suffix.lower()
+
+        # Handle stdin
+        if filename == "-" or not sys.stdin.isatty():
+            from io import StringIO
+
+            # Read CSV from stdin into memory first (stdin is not seekable)
+            stdin_data = sys.stdin.read()
+            df = pl.read_csv(StringIO(stdin_data))
+
+            # Reopen stdin to /dev/tty for proper terminal interaction
+            try:
+                tty = open("/dev/tty")
+                os.dup2(tty.fileno(), sys.stdin.fileno())
+            except (OSError, FileNotFoundError):
+                pass
+
+            sources.append((df, "stdin.csv", "stdin"))
+        # Handle Excel files with multiple sheets
+        elif ext in (".xlsx", ".xls"):
+            sheets = pl.read_excel(filename, sheet_id=0)
+            for sheet_name, df in sheets.items():
+                sources.append((df, filename, sheet_name))
+        # Handle TSV files
+        elif ext in (".tsv", ".tab"):
+            df = pl.read_csv(filename, separator="\t")
+            sources.append((df, filename, filepath.stem))
+        # Handle JSON files
+        elif ext == ".json":
+            df = pl.read_json(filename)
+            sources.append((df, filename, filepath.stem))
+        # Handle Parquet files
+        elif ext == ".parquet":
+            df = pl.read_parquet(filename)
+            sources.append((df, filename, filepath.stem))
+        # Handle regular CSV files
+        else:
+            df = pl.read_csv(filename)
+            sources.append((df, filename, filepath.stem))
+    # Multiple files
+    else:
+        for filename in filenames:
+            filepath = Path(filename)
+            ext = filepath.suffix.lower()
+
+            if ext in (".xlsx", ".xls"):
+                # Read only the first sheet for multiple files
+                df = pl.read_excel(filename)
+                sources.append((df, filename, filepath.stem))
+            elif ext in (".tsv", ".tab"):
+                df = pl.read_csv(filename, separator="\t")
+                sources.append((df, filename, filepath.stem))
+            elif ext == ".json":
+                df = pl.read_json(filename)
+                sources.append((df, filename, filepath.stem))
+            elif ext == ".parquet":
+                df = pl.read_parquet(filename)
+                sources.append((df, filename, filepath.stem))
+            else:
+                df = pl.read_csv(filename)
+                sources.append((df, filename, filepath.stem))
+
+    return sources

dataframe_textual/table_screen.py

@@ -0,0 +1,315 @@
+"""Modal screens for displaying data in tables (row details and frequency)."""
+
+from typing import Any
+
+import polars as pl
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.coordinate import Coordinate
+from textual.renderables.bar import Bar
+from textual.screen import ModalScreen
+from textual.widgets import DataTable
+
+from .common import BOOLS, DtypeConfig, _format_row
+
+
+class TableScreen(ModalScreen):
+    """Base class for modal screens displaying data in a DataTable.
+
+    Provides common functionality for screens that show tabular data with
+    keyboard shortcuts and styling.
+    """
+
+    DEFAULT_CSS = """
+        TableScreen {
+            align: center middle;
+        }
+
+        TableScreen > DataTable {
+            width: auto;
+            min-width: 30;
+            height: auto;
+            border: solid $primary;
+        }
+    """
+
+    def __init__(self, df: pl.DataFrame, id: str | None = None):
+        super().__init__()
+        self.df = df
+        self.id = id
+
+    def compose(self) -> ComposeResult:
+        """Create the table. Must be overridden by subclasses."""
+        self.table = DataTable(zebra_stripes=True, id=self.id)
+        yield self.table
+
+    def on_key(self, event):
+        if event.key in ("q", "escape"):
+            self.app.pop_screen()
+            event.stop()
+        # Prevent key events from propagating to parent screen,
+        # except for the following default key bindings for DataTable
+        elif event.key not in (
+            "up",
+            "down",
+            "right",
+            "left",
+            "pageup",
+            "pagedown",
+            "ctrl+home",
+            "ctrl+end",
+            "home",
+            "end",
+        ):
+            event.stop()
+
+    def _filter_or_highlight_selected_value(
+        self, col_name_value: tuple[str, str] | None, action: str = "filter"
+    ) -> None:
+        """Apply filter or highlight action by the selected value from the frequency table.
+
+        Args:
+            col_name: The name of the column to filter/highlight.
+            col_value: The value to filter/highlight by.
+            action: Either "filter" to filter visible rows, or "highlight" to select matching rows.
+        """
+        if col_name_value is None:
+            return
+        col_name, col_value = col_name_value
+
+        # Handle NULL values
+        if col_value == "-":
+            # Create expression for NULL values
+            expr = pl.col(col_name).is_null()
+            value_display = "[on $primary]NULL[/]"
+        else:
+            # Create expression for the selected value
+            expr = pl.col(col_name) == col_value
+            value_display = f"[on $primary]{col_value}[/]"
+
+        app = self.app
+        matched_indices = set(
+            app.df.with_row_index("__rid__").filter(expr)["__rid__"].to_list()
+        )
+
+        # Apply the action
+        if action == "filter":
+            # Update visible_rows to reflect the filter
+            for i in range(len(app.visible_rows)):
+                app.visible_rows[i] = i in matched_indices
+            title = "Filter"
+            message = f"Filtered by [on $primary]{col_name}[/] = {value_display}"
+        else:  # action == "highlight"
+            # Update selected_rows to reflect the highlights
+            for i in range(len(app.selected_rows)):
+                app.selected_rows[i] = i in matched_indices
+            title = "Highlight"
+            message = f"Highlighted [on $primary]{col_name}[/] = {value_display}"
+
+        # Recreate the table display with updated data in the main app
+        app._setup_table()
+
+        # 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."""
+
+    CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "RowDetailScreen")
+
+    def __init__(self, row_idx: int, df: pl.DataFrame):
+        super().__init__(df, id="row-detail-table")
+        self.row_idx = row_idx
+
+    def on_mount(self) -> None:
+        """Create the detail table."""
+        self.table.add_column("Column")
+        self.table.add_column("Value")
+
+        # Get all columns and values from the dataframe row
+        for col, val, dtype in zip(
+            self.df.columns, self.df.row(self.row_idx), self.df.dtypes
+        ):
+            self.table.add_row(
+                *_format_row([col, val], [None, dtype], apply_justify=False)
+            )
+
+        self.table.cursor_type = "row"
+
+    def on_key(self, event):
+        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"
+            )
+            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"
+            )
+            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):
+            return None  # Invalid row
+
+        col_name = self.df.columns[row_idx]
+        col_value = self.df.item(self.row_idx, row_idx)
+
+        return col_name, col_value
+
+
+class FrequencyScreen(TableScreen):
+    """Modal screen to display frequency of values in a column."""
+
+    CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "FrequencyScreen")
+
+    def __init__(self, col_idx: int, df: pl.DataFrame):
+        super().__init__(df, id="frequency-table")
+        self.col_idx = col_idx
+        self.sorted_columns = {
+            1: True,  # Count
+            2: True,  # %
+        }
+
+    def on_mount(self) -> None:
+        """Create the frequency table."""
+        column = self.df.columns[self.col_idx]
+        dtype = str(self.df.dtypes[self.col_idx])
+        dc = DtypeConfig(dtype)
+
+        # Calculate frequencies using Polars
+        freq_df = self.df[column].value_counts(sort=True).sort("count", descending=True)
+        total_count = len(self.df)
+
+        # Create frequency table
+        self.table.add_column(Text(column, justify=dc.justify), key=column)
+        self.table.add_column(Text("Count", justify="right"), key="Count")
+        self.table.add_column(Text("%", justify="right"), key="%")
+        self.table.add_column(Text("Histogram", justify="left"), key="Histogram")
+
+        # Get style config for Int64 and Float64
+        ds_int = DtypeConfig("Int64")
+        ds_float = DtypeConfig("Float64")
+
+        # Add rows to the frequency table
+        for row_idx, row in enumerate(freq_df.rows()):
+            value, count = row
+            percentage = (count / total_count) * 100
+
+            self.table.add_row(
+                Text(
+                    "-" if value is None else str(value),
+                    style=dc.style,
+                    justify=dc.justify,
+                ),
+                Text(str(count), style=ds_int.style, justify=ds_int.justify),
+                Text(
+                    f"{percentage:.2f}",
+                    style=ds_float.style,
+                    justify=ds_float.justify,
+                ),
+                Bar(
+                    highlight_range=(0.0, percentage / 100 * 10),
+                    width=10,
+                ),
+                key=str(row_idx + 1),
+            )
+
+        # Add a total row
+        self.table.add_row(
+            Text("Total", style="bold", justify=dc.justify),
+            Text(f"{total_count:,}", style="bold", justify="right"),
+            Text("100.00", style="bold", justify="right"),
+            key="total",
+        )
+
+    def on_key(self, event):
+        if event.key == "left_square_bracket":  # '['
+            # Sort by current column in ascending order
+            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)
+            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"
+            )
+            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"
+            )
+            event.stop()
+
+    def _sort_by_column(self, descending: bool) -> None:
+        """Sort the dataframe by the selected column and refresh the main table."""
+        freq_table = self.query_one(DataTable)
+
+        col_idx = freq_table.cursor_column
+        col_dtype = "String"
+
+        sort_dir = self.sorted_columns.get(col_idx)
+        if sort_dir is not None:
+            # If already sorted in the same direction, do nothing
+            if sort_dir == descending:
+                self.notify(
+                    "Already sorted in that order", title="Sort", severity="warning"
+                )
+                return
+
+        self.sorted_columns.clear()
+        self.sorted_columns[col_idx] = descending
+
+        if col_idx == 0:
+            col_name = self.df.columns[self.col_idx]
+            col_dtype = str(self.df.dtypes[self.col_idx])
+        elif col_idx == 1:
+            col_name = "Count"
+            col_dtype = "Int64"
+        elif col_idx == 2:
+            col_name = "%"
+            col_dtype = "Float64"
+
+        def key_fun(freq_col):
+            col_value = freq_col.plain
+
+            if col_dtype == "Int64":
+                return int(col_value)
+            elif col_dtype == "Float64":
+                return float(col_value)
+            elif col_dtype == "Boolean":
+                return BOOLS[col_value]
+            else:
+                return col_value
+
+        # Sort the table
+        freq_table.sort(
+            col_name, key=lambda freq_col: key_fun(freq_col), reverse=descending
+        )
+
+        # Notify the user
+        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:
+        row_idx = self.table.cursor_row
+        if row_idx >= len(self.df.columns):
+            return None  # Skip total row
+
+        col_name = self.df.columns[self.col_idx]
+        col_dtype = self.df.dtypes[self.col_idx]
+
+        cell_value = self.table.get_cell_at(Coordinate(row_idx, 0))
+        col_value = cell_value.plain
+
+        return col_name, DtypeConfig(col_dtype).convert(col_value)