dataframe-textual 0.1.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

dataframe_viewer/data_frame_viewer.py

@@ -1,320 +0,0 @@
-"""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_viewer/table_screen.py

@@ -1,311 +0,0 @@
-"""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.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)
-            )
-
-    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="%")
-
-        # 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,
-                ),
-                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)