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

dataframe_textual/__init__.py

@@ -2,7 +2,7 @@
 
 from .data_frame_help_panel import DataFrameHelpPanel
 from .data_frame_table import DataFrameTable, History
-from .data_frame_viewer import DataFrameViewer, _load_dataframe
+from .data_frame_viewer import DataFrameViewer
 from .table_screen import FrequencyScreen, RowDetailScreen, TableScreen
 from .yes_no_screen import (
     ConfirmScreen,
@@ -31,5 +31,4 @@ __all__ = [
     "FilterScreen",
     "FreezeScreen",
     "OpenFileScreen",
-    "_load_dataframe",
 ]

dataframe_textual/__main__.py

@@ -4,31 +4,24 @@ import argparse
 import sys
 from pathlib import Path
 
+from .common import SUPPORTED_FORMATS, load_dataframe
 from .data_frame_viewer import DataFrameViewer
 
-SUPPORTED_FORMATS = ["csv", "excel", "tsv", "parquet", "json", "ndjson"]
 
+def cli() -> argparse.Namespace:
+    """Parse command-line arguments.
 
-def main() -> None:
-    """Run the DataFrame Viewer application.
-
-    Parses command-line arguments to determine input files or stdin, validates
-    file existence, and launches the interactive DataFrame Viewer application.
-
-    Returns:
-        None
-
-    Raises:
-        SystemExit: If invalid arguments are provided or required files are missing.
+    Determines input files or stdin and validates file existence
     """
     parser = argparse.ArgumentParser(
+        prog="dv",
         description="Interactive terminal based viewer/editor for tabular data (e.g., CSV/Excel).",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="Examples:\n"
-        "  dataframe-textual data.csv\n"
-        "  dataframe-textual file1.csv file2.csv file3.csv\n"
-        "  dataframe-textual data.xlsx  (opens all sheets in tabs)\n"
-        "  cat data.csv | dataframe-textual --format csv\n",
+        "  %(prog)s data.csv\n"
+        "  %(prog)s file1.csv file2.csv file3.csv\n"
+        "  %(prog)s data.xlsx  (opens each sheet in separate tab)\n"
+        "  cat data.csv | %(prog)s --format csv\n",
     )
     parser.add_argument("files", nargs="*", help="Files to view (or read from stdin)")
     parser.add_argument(
@@ -37,27 +30,59 @@ def main() -> None:
         choices=SUPPORTED_FORMATS,
         help="Specify the format of the input files (csv, excel, tsv etc.)",
     )
-    parser.add_argument("-H", "--no-header", action="store_true", help="Specify that input files have no header row")
+    parser.add_argument(
+        "-H",
+        "--no-header",
+        action="store_true",
+        help="Specify that input files have no header row when reading CSV/TSV",
+    )
+    parser.add_argument(
+        "-I", "--no-inferrence", action="store_true", help="Do not infer data types when reading CSV/TSV"
+    )
+    parser.add_argument(
+        "-C", "--comment-prefix", nargs="?", const="#", help="Comment lines are skipped when reading CSV/TSV"
+    )
+    parser.add_argument("-L", "--skip-lines", type=int, default=0, help="Skip lines when reading CSV/TSV")
+    parser.add_argument(
+        "-K", "--skip-rows-after-header", type=int, default=0, help="Skip rows after header when reading CSV/TSV"
+    )
+    parser.add_argument("-U", "--null", nargs="+", help="Values to interpret as null values when reading CSV/TSV")
 
     args = parser.parse_args()
-    filenames = []
+    if args.files is None:
+        args.files = []
 
     # Check if reading from stdin (pipe or redirect)
     if not sys.stdin.isatty():
-        filenames.append("-")
-    if args.files:
+        args.files.append("-")
+    else:
         # Validate all files exist
         for filename in args.files:
             if not Path(filename).exists():
                 print(f"File not found: {filename}")
                 sys.exit(1)
-        filenames.extend(args.files)
 
-    if not filenames:
+    if not args.files:
         parser.print_help()
         sys.exit(1)
 
-    app = DataFrameViewer(*filenames, file_format=args.format, has_header=not args.no_header)
+    return args
+
+
+def main() -> None:
+    """Run the DataFrame Viewer application."""
+    args = cli()
+    sources = load_dataframe(
+        args.files,
+        file_format=args.format,
+        has_header=not args.no_header,
+        infer_schema=not args.no_inferrence,
+        comment_prefix=args.comment_prefix,
+        skip_lines=args.skip_lines,
+        skip_rows_after_header=args.skip_rows_after_header,
+        null_values=args.null,
+    )
+    app = DataFrameViewer(*sources)
     app.run()
 
 

dataframe_textual/common.py

@@ -1,15 +1,17 @@
 """Common utilities and constants for dataframe_viewer."""
 
 import re
+import sys
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any
 
 import polars as pl
 from rich.text import Text
 
-# Special string to represent null value
-NULL = "NULL"
-NULL_DISPLAY = "-"
+# Supported file formats
+SUPPORTED_FORMATS = {"tsv", "csv", "excel", "xlsx", "xls", "parquet", "json", "ndjson"}
+
 
 # Boolean string mappings
 BOOLS = {
@@ -25,6 +27,10 @@ BOOLS = {
     "0": False,
 }
 
+# Special string to represent null value
+NULL = "NULL"
+NULL_DISPLAY = "-"
+
 
 @dataclass
 class DtypeClass:
@@ -51,15 +57,15 @@ STYLES = {
     pl.UInt32: DtypeClass(gtype="integer", style="cyan", justify="right", itype="integer", convert=int),
     pl.UInt64: DtypeClass(gtype="integer", style="cyan", justify="right", itype="integer", convert=int),
     # float
-    pl.Float32: DtypeClass(gtype="float", style="magenta", justify="right", itype="number", convert=float),
-    pl.Float64: DtypeClass(gtype="float", style="magenta", justify="right", itype="number", convert=float),
-    pl.Decimal: DtypeClass(gtype="float", style="magenta", justify="right", itype="number", convert=float),
+    pl.Float32: DtypeClass(gtype="float", style="yellow", justify="right", itype="number", convert=float),
+    pl.Float64: DtypeClass(gtype="float", style="yellow", justify="right", itype="number", convert=float),
+    pl.Decimal: DtypeClass(gtype="float", style="yellow", justify="right", itype="number", convert=float),
     # bool
     pl.Boolean: DtypeClass(gtype="boolean", style="blue", justify="center", itype="text", convert=lambda x: BOOLS[x.lower()]),
     # temporal
-    pl.Date: DtypeClass(gtype="temporal", style="yellow", justify="center", itype="text", convert=str),
-    pl.Datetime: DtypeClass(gtype="temporal", style="yellow", justify="center", itype="text", convert=str),
-    pl.Time: DtypeClass(gtype="temporal", style="yellow", justify="center", itype="text", convert=str),
+    pl.Date: DtypeClass(gtype="temporal", style="magenta", justify="center", itype="text", convert=str),
+    pl.Datetime: DtypeClass(gtype="temporal", style="magenta", justify="center", itype="text", convert=str),
+    pl.Time: DtypeClass(gtype="temporal", style="magenta", justify="center", itype="text", convert=str),
     # unknown
     pl.Unknown: DtypeClass(gtype="unknown", style="", justify="", itype="text", convert=str),
 }
@@ -111,7 +117,27 @@ def DtypeConfig(dtype: pl.DataType) -> DtypeClass:
         return STYLES[pl.Unknown]
 
 
-def format_row(vals, dtypes, apply_justify=True, thousand_separator=False) -> list[Text]:
+def format_float(value: float, thousand_separator: bool = False, precision: int = 2) -> str:
+    """Format a float value, keeping integers without decimal point.
+
+    Args:
+        val: The float value to format.
+        thousand_separator: Whether to include thousand separators. Defaults to False.
+
+    Returns:
+        The formatted float as a string.
+    """
+
+    if (val := int(value)) == value:
+        return f"{val:,}" if thousand_separator else str(val)
+    else:
+        if precision > 0:
+            return f"{value:,.{precision}f}" if thousand_separator else f"{value:.{precision}f}"
+        else:
+            return f"{value:,f}" if thousand_separator else str(value)
+
+
+def format_row(vals, dtypes, styles=None, apply_justify=True, thousand_separator=False) -> list[Text]:
     """Format a single row with proper styling and justification.
 
     Converts raw row values to formatted Rich Text objects with appropriate
@@ -127,7 +153,7 @@ def format_row(vals, dtypes, apply_justify=True, thousand_separator=False) -> li
     """
     formatted_row = []
 
-    for val, dtype in zip(vals, dtypes, strict=True):
+    for idx, (val, dtype) in enumerate(zip(vals, dtypes, strict=True)):
         dc = DtypeConfig(dtype)
 
         # Format the value
@@ -135,16 +161,18 @@ def format_row(vals, dtypes, apply_justify=True, thousand_separator=False) -> li
             text_val = NULL_DISPLAY
         elif dc.gtype == "integer" and thousand_separator:
             text_val = f"{val:,}"
-        elif dc.gtype == "float" and thousand_separator:
-            text_val = f"{val:,}"
+        elif dc.gtype == "float":
+            text_val = format_float(val, thousand_separator)
         else:
             text_val = str(val)
 
         formatted_row.append(
             Text(
                 text_val,
-                style=dc.style,
+                style=styles[idx] if styles and styles[idx] else dc.style,
                 justify=dc.justify if apply_justify else "",
+                overflow="ellipsis",
+                no_wrap=True,
             )
         )
 
@@ -194,7 +222,7 @@ def get_next_item(lst: list[Any], current, offset=1) -> Any:
     return lst[next_index]
 
 
-def parse_polars_expression(expression: str, df: pl.DataFrame, current_col_idx: int) -> str:
+def parse_polars_expression(expression: str, columns: list[str], current_col_idx: int) -> str:
     """Parse and convert an expression to Polars syntax.
 
     Replaces column references with Polars col() expressions:
@@ -212,7 +240,7 @@ def parse_polars_expression(expression: str, df: pl.DataFrame, current_col_idx:
 
     Args:
         expression: The input expression as a string.
-        df: The DataFrame to validate column references.
+        columns: The list of column names in the DataFrame.
         current_col_idx: The index of the currently selected column (0-based). Used for $_ reference.
 
     Returns:
@@ -242,19 +270,19 @@ def parse_polars_expression(expression: str, df: pl.DataFrame, current_col_idx:
 
         if col_ref == "_":
             # Current selected column
-            col_name = df.columns[current_col_idx]
+            col_name = columns[current_col_idx]
         elif col_ref == "#":
             # RIDX is used to store 0-based row index; add 1 for 1-based index
             return f"(pl.col('{RIDX}') + 1)"
         elif col_ref.isdigit():
             # Column by 1-based index
             col_idx = int(col_ref) - 1
-            if col_idx < 0 or col_idx >= len(df.columns):
+            if col_idx < 0 or col_idx >= len(columns):
                 raise ValueError(f"Column index out of range: ${col_ref}")
-            col_name = df.columns[col_idx]
+            col_name = columns[col_idx]
         else:
             # Column by name
-            if col_ref not in df.columns:
+            if col_ref not in columns:
                 raise ValueError(f"Column not found: ${col_ref}")
             col_name = col_ref
 
@@ -283,7 +311,7 @@ def tentative_expr(term: str) -> bool:
     return False
 
 
-def validate_expr(term: str, df: pl.DataFrame, current_col_idx: int) -> pl.Expr | None:
+def validate_expr(term: str, columns: list[str], current_col_idx: int) -> pl.Expr | None:
     """Validate and return the expression.
 
     Parses a user-provided expression string and validates it as a valid Polars expression.
@@ -291,7 +319,7 @@ def validate_expr(term: str, df: pl.DataFrame, current_col_idx: int) -> pl.Expr
 
     Args:
         term: The input expression as a string.
-        df: The DataFrame to validate column references against.
+        columns: The list of column names in the DataFrame.
         current_col_idx: The index of the currently selected column (0-based). Used for $_ reference.
 
     Returns:
@@ -304,7 +332,7 @@ def validate_expr(term: str, df: pl.DataFrame, current_col_idx: int) -> pl.Expr
 
     try:
         # Parse the expression
-        expr_str = parse_polars_expression(term, df, current_col_idx)
+        expr_str = parse_polars_expression(term, columns, current_col_idx)
 
         # Validate by evaluating it
         try:
@@ -318,3 +346,324 @@ def validate_expr(term: str, df: pl.DataFrame, current_col_idx: int) -> pl.Expr
             raise ValueError(f"Failed to evaluate expression `{expr_str}`: {e}") from e
     except Exception as ve:
         raise ValueError(f"Failed to validate expression `{term}`: {ve}") from ve
+
+
+def load_dataframe(
+    filenames: list[str],
+    file_format: str | None = None,
+    has_header: bool = True,
+    infer_schema: bool = True,
+    comment_prefix: str | None = None,
+    skip_lines: int = 0,
+    skip_rows_after_header: int = 0,
+    null_values: list[str] | None = None,
+) -> list[tuple[pl.DataFrame, str, str]]:
+    """Load DataFrames from file specifications.
+
+    Handles loading from multiple files, single files, or stdin. For Excel files,
+    loads all sheets as separate entries. For other formats, loads as single file.
+
+    Args:
+        filenames: List of filenames to load. If single filename is "-", read from stdin.
+        file_format: Optional format specifier for input files (e.g., 'csv', 'excel').
+        has_header: Whether the input files have a header row. Defaults to True.
+        infer_schema: Whether to infer data types for CSV/TSV files. Defaults to True.
+        comment_prefix: Character(s) indicating comment lines in CSV/TSV files. Defaults to None.
+        skip_lines: Number of lines to skip when reading CSV/TSV files. Defaults to 0.
+        skip_rows_after_header: Number of rows to skip after header. Defaults to 0.
+
+    Returns:
+        List of tuples of (DataFrame, filename, tabname) ready for display.
+    """
+    sources = []
+    prefix_sheet = len(filenames) > 1
+
+    for filename in filenames:
+        # Determine file format if not specified
+        if not file_format:
+            ext = Path(filename).suffix.lower()
+            if ext == ".gz" or ext == ".bz2" or ext == ".xz":
+                ext = Path(filename).with_suffix("").suffix.lower()
+            fmt = ext.removeprefix(".")
+
+            # Default to TSV
+            file_format = fmt if fmt in SUPPORTED_FORMATS else "tsv"
+
+        # Load each file
+        sources.extend(
+            load_file(
+                filename,
+                prefix_sheet=prefix_sheet,
+                file_format=file_format,
+                has_header=has_header,
+                infer_schema=infer_schema,
+                comment_prefix=comment_prefix,
+                skip_lines=skip_lines,
+                skip_rows_after_header=skip_rows_after_header,
+                null_values=null_values,
+            )
+        )
+
+    return sources
+
+
+RE_COMPUTE_ERROR = re.compile(r"at column '(.*?)' \(column number \d+\)")
+
+
+def handle_compute_error(
+    err_msg: str,
+    file_format: str | None,
+    infer_schema: bool,
+    schema_overrides: dict[str, pl.DataType] | None = None,
+) -> tuple[bool, dict[str, pl.DataType] | None]:
+    """Handle ComputeError during schema inference and determine retry strategy.
+
+    Analyzes the error message and determines whether to retry with schema overrides,
+    disable schema inference, or exit with an error.
+
+    Args:
+        err_msg: The error message from the ComputeError exception.
+        file_format: The file format being loaded (tsv, csv, etc.).
+        infer_schema: Whether schema inference is currently enabled.
+        schema_overrides: Current schema overrides, if any.
+
+    Returns:
+        A tuple of (infer_schema, schema_overrides):
+
+    Raises:
+        SystemExit: If the error is unrecoverable.
+    """
+    # Already disabled schema inference, cannot recover
+    if not infer_schema:
+        print(f"Error loading with schema inference disabled:\n{err_msg}", file=sys.stderr)
+        sys.exit(1)
+
+    # Schema mismatch error
+    if "found more fields than defined in 'Schema'" in err_msg:
+        print(f"Input might be malformed:\n{err_msg}", file=sys.stderr)
+        sys.exit(1)
+
+    # ComputeError: could not parse `n.a. as of 04.01.022` as `dtype` i64 at column 'PubChemCID' (column number 16)
+    if file_format in ("tsv", "csv") and (m := RE_COMPUTE_ERROR.search(err_msg)):
+        col_name = m.group(1)
+
+        if schema_overrides is None:
+            schema_overrides = {}
+        schema_overrides.update({col_name: pl.String})
+    else:
+        infer_schema = False
+
+    return infer_schema, schema_overrides
+
+
+def load_stdin(
+    stdin_data=None,
+    file_format: str | None = None,
+    has_header: bool = True,
+    infer_schema: bool = True,
+    comment_prefix: str | None = None,
+    skip_lines: int = 0,
+    skip_rows_after_header: int = 0,
+    schema_overrides: dict[str, pl.DataType] | None = None,
+    null_values: list[str] | None = None,
+) -> list[tuple[pl.DataFrame, str, str]]:
+    """Load DataFrame from stdin.
+
+    If a ComputeError occurs during schema inference for a column, attempts to recover
+    by treating that column as a string and retrying the load. This process repeats until
+    all columns are successfully loaded or no further recovery is possible.
+
+    Args:
+        stdin_data: Optional stdin data as string. If None, read from sys.stdin.
+        file_format: Optional format specifier for input files (e.g., 'csv', 'excel').
+        has_header: Whether the input files have a header row. Defaults to True.
+        infer_schema: Whether to infer data types for CSV/TSV files. Defaults to True.
+        comment_prefix: Character(s) indicating comment lines in CSV/TSV files. Defaults to None.
+        skip_lines: Number of lines to skip when reading CSV/TSV files. Defaults to 0.
+        skip_rows_after_header: Number of rows to skip after header. Defaults to 0.
+
+    Returns:
+        List of tuples of (DataFrame, filename, tabname) ready for display.
+    """
+    import os
+    from io import StringIO
+
+    sources = []
+
+    # Read from stdin into memory first (stdin is not seekable)
+    if stdin_data is None:
+        stdin_data = sys.stdin.read()
+
+        # 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
+
+    lf = pl.scan_csv(
+        StringIO(stdin_data),
+        separator="," if file_format == "csv" else "\t",
+        has_header=has_header,
+        infer_schema=infer_schema,
+        comment_prefix=comment_prefix,
+        skip_lines=skip_lines,
+        skip_rows_after_header=skip_rows_after_header,
+        schema_overrides=schema_overrides,
+        null_values=null_values,
+    )
+
+    sources = [(lf, f"stdin.{file_format}" if file_format else "stdin", "stdin")]
+
+    # Attempt to collect, handling ComputeError for schema inference issues
+    try:
+        sources = [(lf.collect(), fn, tn) for lf, fn, tn in sources]
+    except pl.exceptions.ComputeError as ce:
+        # Handle the error and determine retry strategy
+        infer_schema, schema_overrides = handle_compute_error(str(ce), file_format, infer_schema, schema_overrides)
+
+        # Retry loading with updated schema overrides
+        return load_stdin(
+            stdin_data,
+            file_format=file_format,
+            has_header=has_header,
+            infer_schema=infer_schema,
+            comment_prefix=comment_prefix,
+            skip_lines=skip_lines,
+            skip_rows_after_header=skip_rows_after_header,
+            schema_overrides=schema_overrides,
+            null_values=null_values,
+        )
+
+    return sources
+
+
+def load_file(
+    filename: str,
+    first_sheet: bool = False,
+    prefix_sheet: bool = False,
+    file_format: str | None = None,
+    has_header: bool = True,
+    infer_schema: bool = True,
+    comment_prefix: str | None = None,
+    skip_lines: int = 0,
+    skip_rows_after_header: int = 0,
+    schema_overrides: dict[str, pl.DataType] | None = None,
+    null_values: list[str] | None = None,
+) -> list[tuple[pl.DataFrame, str, str]]:
+    """Load a single file.
+
+    For Excel files, when `first_sheet` is True, returns only the first sheet. Otherwise, returns one entry per sheet.
+    For other files or multiple files, returns one entry per file.
+
+    If a ComputeError occurs during schema inference for a column, attempts to recover
+    by treating that column as a string and retrying the load. This process repeats until
+    all columns are successfully loaded or no further recovery is possible.
+
+    Args:
+        filename: Path to file to load.
+        first_sheet: If True, only load first sheet for Excel files. Defaults to False.
+        prefix_sheet: If True, prefix filename to sheet name as the tab name for Excel files. Defaults to False.
+        file_format: Optional format specifier (i.e., 'tsv', 'csv', 'excel', 'parquet', 'json', 'ndjson') for input files.
+                     By default, infers from file extension.
+        has_header: Whether the input files have a header row. Defaults to True.
+        infer_schema: Whether to infer data types for CSV/TSV files. Defaults to True.
+        comment_prefix: Character(s) indicating comment lines in CSV/TSV files. Defaults to None.
+        skip_lines: Number of lines to skip when reading CSV/TSV files. The header will be parsed at this offset. Defaults to 0.
+        skip_rows_after_header: Number of rows to skip after header when reading CSV/TSV files. Defaults to 0.
+
+    Returns:
+        List of tuples of (DataFrame, filename, tabname).
+    """
+    sources = []
+
+    if filename == "-":
+        return load_stdin(
+            file_format=file_format,
+            has_header=has_header,
+            infer_schema=infer_schema,
+            comment_prefix=comment_prefix,
+            skip_lines=skip_lines,
+            skip_rows_after_header=skip_rows_after_header,
+            schema_overrides=schema_overrides,
+            null_values=null_values,
+        )
+
+    filepath = Path(filename)
+
+    # Load based on file format
+    if file_format in ("tsv", "csv"):
+        lf = pl.scan_csv(
+            filename,
+            separator="\t" if file_format == "tsv" else ",",
+            has_header=has_header,
+            infer_schema=infer_schema,
+            comment_prefix=comment_prefix,
+            skip_lines=skip_lines,
+            skip_rows_after_header=skip_rows_after_header,
+            schema_overrides=schema_overrides,
+            null_values=null_values,
+        )
+        sources.append((lf, filename, filepath.stem))
+    elif file_format in ("xlsx", "xls", "excel"):
+        if first_sheet:
+            # Read only the first sheet for multiple files
+            lf = pl.read_excel(filename).lazy()
+            sources.append((lf, filename, filepath.stem))
+        else:
+            # For single file, expand all sheets
+            sheets = pl.read_excel(filename, sheet_id=0)
+            for sheet_name, df in sheets.items():
+                tabname = f"{filepath.stem}_{sheet_name}" if prefix_sheet else sheet_name
+                sources.append((df.lazy(), filename, tabname))
+    elif file_format == "parquet":
+        lf = pl.scan_parquet(filename)
+        sources.append((lf, filename, filepath.stem))
+    elif file_format == "json":
+        lf = pl.read_json(filename).lazy()
+        sources.append((lf, filename, filepath.stem))
+    elif file_format == "ndjson":
+        lf = pl.scan_ndjson(filename, schema_overrides=schema_overrides)
+        sources.append((lf, filename, filepath.stem))
+    else:
+        raise ValueError(f"Unsupported file format: {file_format}. Supported formats are: {SUPPORTED_FORMATS}")
+
+    # Attempt to collect, handling ComputeError for schema inference issues
+    try:
+        sources = [(lf.collect(), fn, tn) for lf, fn, tn in sources]
+    except pl.exceptions.ComputeError as ce:
+        # Handle the error and determine retry strategy
+        infer_schema, schema_overrides = handle_compute_error(str(ce), file_format, infer_schema, schema_overrides)
+
+        # Retry loading with updated schema overrides
+        return load_file(
+            filename,
+            file_format=file_format,
+            has_header=has_header,
+            infer_schema=infer_schema,
+            comment_prefix=comment_prefix,
+            skip_lines=skip_lines,
+            skip_rows_after_header=skip_rows_after_header,
+            schema_overrides=schema_overrides,
+            null_values=null_values,
+        )
+
+    return sources
+
+
+def now() -> str:
+    """Get the current local time as a formatted string."""
+    import time
+
+    return time.strftime("%m/%d/%Y %H:%M:%S", time.localtime())
+
+
+async def sleep_async(seconds: float) -> None:
+    """Async sleep to yield control back to the event loop.
+
+    Args:
+        seconds: The number of seconds to sleep.
+    """
+    import asyncio
+
+    await asyncio.sleep(seconds)

dataframe_textual/data_frame_help_panel.py

@@ -79,10 +79,12 @@ class DataFrameHelpPanel(Widget):
             None
         """
 
-        def update_help(focused_widget: Widget | None):
-            self.update_help(focused_widget)
+        # def update_help(focused_widget: Widget | None):
+        #     self.update_help(focused_widget)
 
-        self.watch(self.screen, "focused", update_help)
+        # self.watch(self.screen, "focused", update_help)
+
+        self.update_help(self.screen.focused)
 
     def update_help(self, focused_widget: Widget | None) -> None:
         """Update the help for the focused widget.
@@ -96,7 +98,7 @@ class DataFrameHelpPanel(Widget):
             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 ""
+            help = (self.app.HELP or "") + "\n" + (focused_widget.HELP or "")
             if not help:
                 self.remove_class("-show-help")
             try: