dataframe-textual 0.2.1__py3-none-any.whl

dataframe_textual/__init__.py

@@ -0,0 +1,35 @@
+"""DataFrame Viewer - Interactive CSV/Excel viewer for the terminal."""
+
+from .data_frame_help_panel import DataFrameHelpPanel
+from .data_frame_table import DataFrameTable, History
+from .data_frame_viewer import DataFrameViewer, _load_dataframe
+from .table_screen import FrequencyScreen, RowDetailScreen, TableScreen
+from .yes_no_screen import (
+    ConfirmScreen,
+    EditCellScreen,
+    FilterScreen,
+    FreezeScreen,
+    OpenFileScreen,
+    SaveFileScreen,
+    SearchScreen,
+    YesNoScreen,
+)
+
+__all__ = [
+    "DataFrameViewer",
+    "DataFrameHelpPanel",
+    "DataFrameTable",
+    "History",
+    "TableScreen",
+    "RowDetailScreen",
+    "FrequencyScreen",
+    "YesNoScreen",
+    "SaveFileScreen",
+    "ConfirmScreen",
+    "EditCellScreen",
+    "SearchScreen",
+    "FilterScreen",
+    "FreezeScreen",
+    "OpenFileScreen",
+    "_load_dataframe",
+]

dataframe_textual/__main__.py

@@ -0,0 +1,48 @@
+"""Entry point for running DataFrameViewer as a module."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .data_frame_viewer import DataFrameViewer
+
+
+def main():
+    """Run the DataFrame Viewer application."""
+    parser = argparse.ArgumentParser(
+        description="Interactive CSV/Excel viewer for the terminal (Textual version)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="Examples:\n"
+        "  dataframe-viewer data.csv\n"
+        "  dataframe-viewer file1.csv file2.csv file3.csv\n"
+        "  dataframe-viewer data.xlsx  (opens all sheets in tabs)\n"
+        "  cat data.csv | dataframe-viewer\n",
+    )
+    parser.add_argument(
+        "files", nargs="*", help="CSV or Excel files to view (or read from stdin)"
+    )
+
+    args = parser.parse_args()
+    filenames = []
+
+    # Check if reading from stdin (pipe or redirect)
+    if not sys.stdin.isatty():
+        filenames = ["-"]
+    elif args.files:
+        # Validate all files exist
+        for filename in args.files:
+            if not Path(filename).exists():
+                print(f"File not found: {filename}")
+                sys.exit(1)
+        filenames = args.files
+
+    if not filenames:
+        parser.print_help()
+        sys.exit(1)
+
+    app = DataFrameViewer(*filenames)
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

dataframe_textual/common.py

@@ -0,0 +1,204 @@
+"""Common utilities and constants for dataframe_viewer."""
+
+import re
+from dataclasses import dataclass
+from typing import Any
+
+import polars as pl
+from rich.text import Text
+
+# Boolean string mappings
+BOOLS = {
+    "true": True,
+    "t": True,
+    "yes": True,
+    "y": True,
+    "1": True,
+    "false": False,
+    "f": False,
+    "no": False,
+    "n": False,
+    "0": False,
+}
+
+# itype is used by Input widget for input validation
+# fmt: off
+STYLES = {
+    "Int64": {"style": "cyan", "justify": "right", "itype": "integer", "convert": int},
+    "Float64": {"style": "magenta", "justify": "right", "itype": "number", "convert": float},
+    "String": {"style": "green", "justify": "left", "itype": "text", "convert": str},
+    "Boolean": {"style": "blue", "justify": "center", "itype": "text", "convert": lambda x: BOOLS[x.lower()]},
+    "Date": {"style": "blue", "justify": "center", "itype": "text", "convert": str},
+    "Datetime": {"style": "blue", "justify": "center", "itype": "text", "convert": str},
+}
+# fmt: on
+
+
+@dataclass
+class DtypeConfig:
+    style: str
+    justify: str
+    itype: str
+    convert: Any
+
+    def __init__(self, dtype: pl.DataType):
+        dc = STYLES.get(
+            str(dtype), {"style": "", "justify": "", "itype": "text", "convert": str}
+        )
+        self.style = dc["style"]
+        self.justify = dc["justify"]
+        self.itype = dc["itype"]
+        self.convert = dc["convert"]
+
+
+# Subscript digits mapping for sort indicators
+SUBSCRIPT_DIGITS = {
+    0: "₀",
+    1: "₁",
+    2: "₂",
+    3: "₃",
+    4: "₄",
+    5: "₅",
+    6: "₆",
+    7: "₇",
+    8: "₈",
+    9: "₉",
+}
+
+# Cursor types ("none" removed)
+CURSOR_TYPES = ["row", "column", "cell"]
+
+# Pagination settings
+INITIAL_BATCH_SIZE = 100  # Load this many rows initially
+BATCH_SIZE = 50  # Load this many rows when scrolling
+
+
+def _format_row(vals, dtypes, apply_justify=True) -> list[Text]:
+    """Format a single row with proper styling and justification.
+
+    Args:
+        vals: The list of values in the row.
+        dtypes: The list of data types corresponding to each value.
+        apply_justify: Whether to apply justification styling. Defaults to True.
+    """
+    formatted_row = []
+
+    for val, dtype in zip(vals, dtypes, strict=True):
+        dc = DtypeConfig(dtype)
+
+        # Format the value
+        if val is None:
+            text_val = "-"
+        elif str(dtype).startswith("Float"):
+            text_val = f"{val:.4g}"
+        else:
+            text_val = str(val)
+
+        formatted_row.append(
+            Text(
+                text_val,
+                style=dc.style,
+                justify=dc.justify if apply_justify else "",
+            )
+        )
+
+    return formatted_row
+
+
+def _rindex(lst: list, value) -> int:
+    """Return the last index of value in a list. Return -1 if not found."""
+    for i, item in enumerate(reversed(lst)):
+        if item == value:
+            return len(lst) - 1 - i
+    return -1
+
+
+def _next(lst: list[Any], current, offset=1) -> Any:
+    """Return the next item in the list after the current item, cycling if needed."""
+    if current not in lst:
+        raise ValueError("Current item not in list")
+    current_index = lst.index(current)
+    next_index = (current_index + offset) % len(lst)
+    return lst[next_index]
+
+
+def parse_filter_expression(
+    expression: str, df: pl.DataFrame, current_col_idx: int
+) -> str:
+    """Parse and convert a filter expression to Polars syntax.
+
+    Supports:
+    - $_ - Current selected column
+    - $1, $2, etc. - Column by 1-based index
+    - $col_name - Column by name
+    - Comparison operators: ==, !=, <, >, <=, >=
+    - Logical operators: &&, ||
+    - String literals: 'text', "text"
+    - Numeric literals: integers and floats
+
+    Examples:
+    - "$_ > 50" -> "pl.col('current_col') > 50"
+    - "$1 > 50" -> "pl.col('col0') > 50"
+    - "$name == 'Alex'" -> "pl.col('name') == 'Alex'"
+    - "$1 > 3 && $name == 'Alex'" -> "(pl.col('col0') > 3) & (pl.col('name') == 'Alex')"
+    - "$age < $salary" -> "pl.col('age') < pl.col('salary')"
+
+    Args:
+        expression: The filter expression as a string.
+        df: The DataFrame to validate column references.
+        current_col_idx: The index of the currently selected column (0-based). Used for $_ reference.
+
+    Returns:
+        A Python expression string that can be eval'd with Polars symbols.
+
+    Raises:
+        ValueError: If the expression contains invalid column references.
+        SyntaxError: If the expression has invalid syntax.
+    """
+    # Tokenize the expression
+    # Pattern matches: $_, $index, $identifier, strings, operators, numbers, etc.
+    token_pattern = r'\$_|\$\d+|\$\w+|\'[^\']*\'|"[^"]*"|&&|\|\||<=|>=|!=|==|[+\-*/%<>=()]|\d+\.?\d*|\w+|.'
+
+    tokens = re.findall(token_pattern, expression)
+
+    if not tokens:
+        raise ValueError("Expression is empty")
+
+    # Convert tokens to Polars expression syntax
+    converted_tokens = []
+    for token in tokens:
+        if token.startswith("$"):
+            # Column reference
+            col_ref = token[1:]
+
+            # Special case: $_ refers to the current selected column
+            if col_ref == "_":
+                col_name = df.columns[current_col_idx]
+            # Check if it's a numeric index
+            elif col_ref.isdigit():
+                col_idx = int(col_ref) - 1  # Convert to 0-based index
+                if col_idx < 0 or col_idx >= len(df.columns):
+                    raise ValueError(f"Column index out of range: ${col_ref}")
+                col_name = df.columns[col_idx]
+            else:
+                # It's a column name
+                if col_ref not in df.columns:
+                    raise ValueError(f"Column not found: ${col_ref}")
+                col_name = col_ref
+
+            converted_tokens.append(f"pl.col('{col_name}')")
+
+        elif token in ("&&", "||"):
+            # Convert logical operators and wrap surrounding expressions in parentheses
+            if token == "&&":
+                converted_tokens.append(") & (")
+            else:
+                converted_tokens.append(") | (")
+
+        else:
+            # Keep as-is (operators, numbers, strings, parentheses)
+            converted_tokens.append(token)
+
+    # Join tokens with space to ensure proper separation
+    result = "(" + " ".join(converted_tokens) + ")"
+    return result

dataframe_textual/data_frame_help_panel.py

@@ -0,0 +1,98 @@
+"""Help panel widget for displaying context-sensitive help."""
+
+from textwrap import dedent
+
+from textual.containers import VerticalScroll
+from textual.css.query import NoMatches
+from textual.widget import Widget
+from textual.widgets import Markdown
+
+
+class DataFrameHelpPanel(Widget):
+    """
+    Shows context sensitive help for the currently focused widget.
+
+    Modified from Textual's built-in HelpPanel with KeyPanel removed.
+    """
+
+    DEFAULT_CSS = """
+        DataFrameHelpPanel {
+            split: right;
+            width: 33%;
+            min-width: 30;
+            max-width: 60;
+            border-left: vkey $foreground 30%;
+            padding: 0 1;
+            height: 1fr;
+            padding-right: 1;
+            layout: vertical;
+            height: 100%;
+
+            &:ansi {
+                background: ansi_default;
+                border-left: vkey ansi_black;
+
+                Markdown {
+                    background: ansi_default;
+                }
+                .bindings-table--divide {
+                    color: transparent;
+                }
+            }
+
+            #widget-help {
+                height: auto;
+                width: 1fr;
+                padding: 0;
+                margin: 0;
+                padding: 1 0;
+                margin-top: 1;
+                display: none;
+                background: $panel;
+
+                &:ansi {
+                    background: ansi_default;
+                }
+
+                MarkdownBlock {
+                    padding-left: 2;
+                    padding-right: 2;
+                }
+            }
+
+            &.-show-help #widget-help {
+                display: block;
+            }
+        }
+    """
+
+    DEFAULT_CLASSES = "-textual-system"
+
+    def on_mount(self):
+        def update_help(focused_widget: Widget | None):
+            self.update_help(focused_widget)
+
+        self.watch(self.screen, "focused", update_help)
+
+    def update_help(self, focused_widget: Widget | None) -> None:
+        """Update the help for the focused widget.
+
+        Args:
+            focused_widget: The currently focused widget, or `None` if no widget was focused.
+        """
+        if not self.app.app_focus:
+            return
+        if not self.screen.is_active:
+            return
+        self.set_class(focused_widget is not None, "-show-help")
+        if focused_widget is not None:
+            help = self.app.HELP + "\n" + focused_widget.HELP or ""
+            if not help:
+                self.remove_class("-show-help")
+            try:
+                self.query_one(Markdown).update(dedent(help))
+            except NoMatches:
+                pass
+
+    def compose(self):
+        yield VerticalScroll(Markdown(id="widget-help"))