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

dataframe_textual/data_frame_viewer.py

@@ -1,7 +1,6 @@
 """DataFrame Viewer application and utilities."""
 
 import os
-import sys
 from functools import partial
 from pathlib import Path
 from textwrap import dedent
@@ -11,9 +10,9 @@ 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 textual.widgets.tabbed_content import ContentTabs
 
-from .common import get_next_item
+from .common import 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
@@ -27,7 +26,7 @@ class DataFrameViewer(App):
 
         ## 🎯 File & Tab Management
         - **Ctrl+O** - 📁 Add a new tab
-        - **Ctrl+Shift+S** - 💾 Save all tabs
+        - **Ctrl+A** - 💾 Save all tabs
         - **Ctrl+W** - ❌ Close current tab
         - **>** or **b** - ▶️ Next tab
         - **<** - ◀️ Previous tab
@@ -35,7 +34,7 @@ class DataFrameViewer(App):
         - **q** - 🚪 Quit application
 
         ## 🎨 View & Settings
-        - **Ctrl+H** - ❓ Toggle this help panel
+        - **F1** - ❓ Toggle this help panel
         - **k** - 🌙 Cycle through themes
 
         ## ⭐ Features
@@ -52,48 +51,42 @@ class DataFrameViewer(App):
 
     BINDINGS = [
         ("q", "quit", "Quit"),
-        ("ctrl+h", "toggle_help_panel", "Help"),
+        ("f1", "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+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"),
     ]
 
     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 */
+            height: 1fr;
         }
-
-        TabbedContent ContentTab.active {
-            background: $primary;
-            color: $text;
+        ContentTab.-active {
+            background: $block-cursor-background; /* Same as underline */
         }
     """
 
-    def __init__(self, *filenames: str, file_format: str | None = None, has_header: bool = True) -> None:
+    def __init__(self, *sources: str) -> None:
         """Initialize the DataFrame Viewer application.
 
-        Loads dataframes from provided filenames and prepares the tabbed interface.
+        Loads data from provided sources and prepares the tabbed interface.
 
         Args:
-            *filenames: Variable number of file paths to load (CSV, Excel, Parquet, etc).
-            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.
+            sources: sources to load dataframes from, each as a tuple of
+                     (DataFrame, filename, tabname).
 
         Returns:
             None
         """
         super().__init__()
-        self.sources = _load_dataframe(filenames, file_format, has_header=has_header)
+        self.sources = sources
         self.tabs: dict[TabPane, DataFrameTable] = {}
         self.help_panel = None
 
@@ -111,19 +104,29 @@ class DataFrameViewer(App):
         with self.tabbed:
             seen_names = set()
             for idx, (df, filename, tabname) in enumerate(self.sources, start=1):
+                tab_id = f"tab_{idx}"
+
+                if not tabname:
+                    tabname = Path(filename).stem or tab_id
+
                 # Ensure unique tab names
-                if tabname in seen_names:
-                    tabname = f"{tabname}_{idx}"
+                counter = 1
+                while tabname in seen_names:
+                    tabname = f"{tabname}_{counter}"
+                    counter += 1
                 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")
+                    self.notify(
+                        f"Error loading [$error]{filename}[/]: Try [$accent]-I[/] to disable schema inference",
+                        severity="error",
+                    )
+                    self.log(f"Error loading `{filename}`: {str(e)}")
 
     def on_mount(self) -> None:
         """Set up the application when it starts.
@@ -174,12 +177,6 @@ class DataFrameViewer(App):
         if table.loaded_rows == 0:
             table._setup_table()
 
-        # 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")
-
     def action_toggle_help_panel(self) -> None:
         """Toggle the help panel on or off.
 
@@ -300,12 +297,12 @@ class DataFrameViewer(App):
         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.collect(), filename, tabname)
+                for lf, filename, tabname in load_file(filename, prefix_sheet=True):
+                    self._add_tab(lf, filename, tabname)
                     n_tab += 1
-                self.notify(f"Added [$accent]{n_tab}[/] tab(s) for [$success]{filename}[/]", title="Open")
+                # self.notify(f"Added [$accent]{n_tab}[/] tab(s) for [$success]{filename}[/]", title="Open")
             except Exception as e:
-                self.notify(f"Error: {e}", title="Open", severity="error")
+                self.notify(f"Error loading [$error]{filename}[/]: {str(e)}", title="Open", severity="error")
         else:
             self.notify(f"File does not exist: [$warning]{filename}[/]", title="Open", severity="warning")
 
@@ -317,15 +314,18 @@ class DataFrameViewer(App):
         if this is no longer the only tab.
 
         Args:
-            df: The Polars DataFrame to display in the new tab.
+            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
         """
-        if any(tab.name == tabname for tab in self.tabs):
-            tabname = f"{tabname}_{len(self.tabs) + 1}"
+        # Ensure unique tab names
+        counter = 1
+        while any(tab.name == tabname for tab in self.tabs):
+            tabname = f"{tabname}_{counter}"
+            counter += 1
 
         # Find an available tab index
         tab_idx = f"tab_{len(self.tabs) + 1}"
@@ -365,108 +365,6 @@ class DataFrameViewer(App):
                 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")
+                    # self.notify(f"Closed tab [$success]{active_pane.name}[/]", title="Close")
         except NoMatches:
             pass
-
-
-def _load_dataframe(
-    filenames: list[str], file_format: str | None = None, has_header: bool = True
-) -> list[tuple[pl.LazyFrame, 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.
-
-    Returns:
-        List of tuples of (LazyFrame, filename, tabname) ready for display.
-    """
-    sources = []
-
-    prefix_sheet = len(filenames) > 1
-
-    for filename in filenames:
-        sources.extend(_load_file(filename, prefix_sheet=prefix_sheet, file_format=file_format, has_header=has_header))
-    return sources
-
-
-def _load_file(
-    filename: str,
-    first_sheet: bool = False,
-    prefix_sheet: bool = False,
-    file_format: str | None = None,
-    has_header: bool = True,
-) -> list[tuple[pl.LazyFrame, str, str]]:
-    """Load a single file and return list of sources.
-
-    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.
-
-    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 for input files (e.g., 'csv', 'excel', 'tsv', 'parquet', 'json', 'ndjson').
-
-    Returns:
-        List of tuples of (LazyFrame, filename, tabname).
-    """
-    sources = []
-
-    if filename == "-":
-        from io import StringIO
-
-        # Read from stdin into memory first (stdin is not seekable)
-        stdin_data = sys.stdin.read()
-        lf = pl.scan_csv(StringIO(stdin_data), has_header=has_header, separator="," if file_format == "csv" else "\t")
-
-        # 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((lf, "stdin.tsv" if file_format == "tsv" else "stdin.csv", "stdin"))
-        return sources
-
-    filepath = Path(filename)
-    ext = filepath.suffix.lower()
-
-    if file_format == "csv" or ext == ".csv":
-        lf = pl.scan_csv(filename, has_header=has_header)
-        sources.append((lf, filename, filepath.stem))
-    elif file_format == "excel" or ext in (".xlsx", ".xls"):
-        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 == "tsv" or ext in (".tsv", ".tab"):
-        lf = pl.scan_csv(filename, has_header=has_header, separator="\t")
-        sources.append((lf, filename, filepath.stem))
-    elif file_format == "parquet" or ext == ".parquet":
-        lf = pl.scan_parquet(filename)
-        sources.append((lf, filename, filepath.stem))
-    elif file_format == "json" or ext == ".json":
-        df = pl.read_json(filename)
-        sources.append((df, filename, filepath.stem))
-    elif file_format == "ndjson" or ext == ".ndjson":
-        lf = pl.scan_ndjson(filename)
-        sources.append((lf, filename, filepath.stem))
-    else:
-        # Treat other formats as TSV
-        lf = pl.scan_csv(filename, has_header=has_header, separator="\t")
-        sources.append((lf, filename, filepath.stem))
-
-    return sources

dataframe_textual/sql_screen.py

@@ -0,0 +1,202 @@
+"""Modal screens for Polars sql manipulation"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .data_frame_table import DataFrameTable
+
+import polars as pl
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Label, SelectionList, TextArea
+from textual.widgets.selection_list import Selection
+
+
+class SqlScreen(ModalScreen):
+    """Base class for modal screens handling SQL query."""
+
+    DEFAULT_CSS = """
+        SqlScreen {
+            align: center middle;
+        }
+
+        SqlScreen > Container {
+            width: auto;
+            height: auto;
+            border: heavy $accent;
+            border-title-color: $accent;
+            border-title-background: $panel;
+            border-title-style: bold;
+            background: $background;
+            padding: 1 2;
+            overflow: auto;
+        }
+
+        #button-container {
+            width: auto;
+            margin: 1 0 0 0;
+            height: 3;
+            align: center middle;
+        }
+
+        Button {
+            margin: 0 2;
+        }
+
+    """
+
+    def __init__(self, dftable: "DataFrameTable", on_yes_callback=None) -> None:
+        """Initialize the SQL screen."""
+        super().__init__()
+        self.dftable = dftable  # DataFrameTable
+        self.df: pl.DataFrame = dftable.df  # Polars DataFrame
+        self.on_yes_callback = on_yes_callback
+
+    def compose(self) -> ComposeResult:
+        """Compose the SQL screen widget structure."""
+        # Shared by subclasses
+        with Horizontal(id="button-container"):
+            yield Button("Apply", id="yes", variant="success")
+            yield Button("Cancel", id="no", variant="error")
+
+    def on_key(self, event) -> None:
+        """Handle key press events in the SQL screen"""
+        if event.key in ("q", "escape"):
+            self.app.pop_screen()
+            event.stop()
+        elif event.key == "enter":
+            self._handle_yes()
+            event.stop()
+        elif event.key == "escape":
+            self.dismiss(None)
+            event.stop()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press events in the SQL screen."""
+        if event.button.id == "yes":
+            self._handle_yes()
+        elif event.button.id == "no":
+            self.dismiss(None)
+
+    def _handle_yes(self) -> None:
+        """Handle Yes button/Enter key press."""
+        if self.on_yes_callback:
+            result = self.on_yes_callback()
+            self.dismiss(result)
+        else:
+            self.dismiss(True)
+
+
+class SimpleSqlScreen(SqlScreen):
+    """Simple SQL query screen."""
+
+    DEFAULT_CSS = SqlScreen.DEFAULT_CSS.replace("SqlScreen", "SimpleSqlScreen")
+
+    CSS = """
+        SimpleSqlScreen SelectionList {
+            width: auto;
+            min-width: 40;
+            margin: 1 0;
+        }
+
+        SimpleSqlScreen SelectionList:blur {
+            border: solid $secondary;
+        }
+
+        SimpleSqlScreen Label {
+            width: auto;
+        }
+
+        SimpleSqlScreen Input {
+            width: auto;
+        }
+
+        SimpleSqlScreen Input:blur {
+            border: solid $secondary;
+        }
+
+        #button-container {
+            min-width: 40;
+        }
+    """
+
+    def __init__(self, dftable: "DataFrameTable") -> None:
+        """Initialize the simple SQL screen.
+
+        Sets up the modal screen with reference to the main DataFrameTable widget
+        and stores the DataFrame for display.
+
+        Args:
+            dftable: Reference to the parent DataFrameTable widget.
+
+        Returns:
+            None
+        """
+        super().__init__(dftable, on_yes_callback=self._handle_simple)
+
+    def compose(self) -> ComposeResult:
+        """Compose the simple SQL screen widget structure."""
+        with Container(id="sql-container") as container:
+            container.border_title = "SQL Query"
+            yield Label("Select columns (default to all):", id="select-label")
+            yield SelectionList(*[Selection(col, col) for col in self.df.columns], id="column-selection")
+            yield Label("Where condition (optional)", id="where-label")
+            yield Input(placeholder="e.g., age > 30 and height < 180", id="where-input")
+            yield from super().compose()
+
+    def _handle_simple(self) -> None:
+        """Handle Yes button/Enter key press."""
+        selections = self.query_one(SelectionList).selected
+        columns = ", ".join(f"`{s}`" for s in selections) if selections else "*"
+        where = self.query_one(Input).value.strip()
+
+        return columns, where
+
+
+class AdvancedSqlScreen(SqlScreen):
+    """Advanced SQL query screen."""
+
+    DEFAULT_CSS = SqlScreen.DEFAULT_CSS.replace("SqlScreen", "AdvancedSqlScreen")
+
+    CSS = """
+        AdvancedSqlScreen TextArea {
+            width: auto;
+            min-width: 60;
+            height: auto;
+            min-height: 10;
+        }
+
+        #button-container {
+            min-width: 60;
+        }
+    """
+
+    def __init__(self, dftable: "DataFrameTable") -> None:
+        """Initialize the simple SQL screen.
+
+        Sets up the modal screen with reference to the main DataFrameTable widget
+        and stores the DataFrame for display.
+
+        Args:
+            dftable: Reference to the parent DataFrameTable widget.
+
+        Returns:
+            None
+        """
+        super().__init__(dftable, on_yes_callback=self._handle_advanced)
+
+    def compose(self) -> ComposeResult:
+        """Compose the advanced SQL screen widget structure."""
+        with Container(id="sql-container") as container:
+            container.border_title = "Advanced SQL Query"
+            yield TextArea.code_editor(
+                placeholder="Enter SQL query (use `self` as the table name), e.g., \n\nSELECT * \nFROM self \nWHERE age > 30",
+                id="sql-textarea",
+                language="sql",
+            )
+            yield from super().compose()
+
+    def _handle_advanced(self) -> None:
+        """Handle Yes button/Enter key press."""
+        return self.query_one(TextArea).text.strip()

dataframe_textual/table_screen.py

@@ -13,7 +13,7 @@ from textual.renderables.bar import Bar
 from textual.screen import ModalScreen
 from textual.widgets import DataTable
 
-from .common import NULL, NULL_DISPLAY, RIDX, DtypeConfig, format_row
+from .common import NULL, NULL_DISPLAY, RIDX, DtypeConfig, format_float, format_row
 
 
 class TableScreen(ModalScreen):
@@ -30,12 +30,14 @@ class TableScreen(ModalScreen):
 
         TableScreen > DataTable {
             width: auto;
-            min-width: 30;
+            height: auto;
             border: solid $primary;
+            max-width: 100%;
+            overflow: auto;
         }
     """
 
-    def __init__(self, dftable: DataFrameTable) -> None:
+    def __init__(self, dftable: "DataFrameTable") -> None:
         """Initialize the table screen.
 
         Sets up the base modal screen with reference to the main DataFrameTable widget
@@ -48,8 +50,8 @@ class TableScreen(ModalScreen):
             None
         """
         super().__init__()
-        self.df: pl.DataFrame = dftable.df  # Polars DataFrame
         self.dftable = dftable  # DataFrameTable
+        self.df: pl.DataFrame = dftable.df  # Polars DataFrame
         self.thousand_separator = False  # Whether to use thousand separators in numbers
 
     def compose(self) -> ComposeResult:
@@ -179,7 +181,12 @@ class RowDetailScreen(TableScreen):
         # Get all columns and values from the dataframe row
         for col, val, dtype in zip(self.df.columns, self.df.row(self.ridx), self.df.dtypes):
             self.table.add_row(
-                *format_row([col, val], [None, dtype], apply_justify=False, thousand_separator=self.thousand_separator)
+                *format_row(
+                    [col, val],
+                    [None, dtype],
+                    apply_justify=False,
+                    thousand_separator=self.thousand_separator,
+                )
             )
 
         self.table.cursor_type = "row"
@@ -223,7 +230,7 @@ class StatisticsScreen(TableScreen):
 
     CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "StatisticsScreen")
 
-    def __init__(self, dftable: DataFrameTable, col_idx: int | None = None):
+    def __init__(self, dftable: "DataFrameTable", col_idx: int | None = None):
         super().__init__(dftable)
         self.col_idx = col_idx  # None for dataframe statistics, otherwise column index
 
@@ -238,9 +245,11 @@ class StatisticsScreen(TableScreen):
         if self.col_idx is None:
             # Dataframe statistics
             self._build_dataframe_stats()
+            self.table.cursor_type = "column"
         else:
             # Column statistics
             self._build_column_stats()
+            self.table.cursor_type = "row"
 
     def _build_column_stats(self) -> None:
         """Build statistics for a single column."""
@@ -271,10 +280,10 @@ class StatisticsScreen(TableScreen):
             value = stat_value
             if stat_value is None:
                 value = NULL_DISPLAY
-            elif dc.gtype == "int" and self.thousand_separator:
+            elif dc.gtype == "integer" and self.thousand_separator:
                 value = f"{stat_value:,}"
             elif dc.gtype == "float":
-                value = f"{stat_value:,.2f}" if self.thousand_separator else f"{stat_value:.2f}"
+                value = format_float(stat_value, self.thousand_separator)
             else:
                 value = str(stat_value)
 
@@ -291,6 +300,10 @@ class StatisticsScreen(TableScreen):
         if False in self.dftable.visible_rows:
             lf = lf.filter(self.dftable.visible_rows)
 
+        # Apply only to non-hidden columns
+        if self.dftable.hidden_columns:
+            lf = lf.select(pl.exclude(self.dftable.hidden_columns))
+
         # Get dataframe statistics
         stats_df = lf.collect().describe()
 
@@ -321,10 +334,10 @@ class StatisticsScreen(TableScreen):
                 value = stat_value
                 if stat_value is None:
                     value = NULL_DISPLAY
-                elif dc.gtype == "int" and self.thousand_separator:
+                elif dc.gtype == "integer" and self.thousand_separator:
                     value = f"{stat_value:,}"
                 elif dc.gtype == "float":
-                    value = f"{stat_value:,.2f}" if self.thousand_separator else f"{stat_value:.2f}"
+                    value = format_float(stat_value, self.thousand_separator)
                 else:
                     value = str(stat_value)
 
@@ -338,15 +351,16 @@ class FrequencyScreen(TableScreen):
 
     CSS = TableScreen.DEFAULT_CSS.replace("TableScreen", "FrequencyScreen")
 
-    def __init__(self, col_idx: int, dftable: DataFrameTable):
+    def __init__(self, col_idx: int, dftable: "DataFrameTable") -> None:
         super().__init__(dftable)
         self.col_idx = col_idx
         self.sorted_columns = {
             1: True,  # Count
         }
-        self.df: pl.DataFrame = (
-            dftable.df[dftable.df.columns[self.col_idx]].value_counts(sort=True).sort("count", descending=True)
-        )
+
+        df = dftable.df.filter(dftable.visible_rows) if False in dftable.visible_rows else dftable.df
+        self.total_count = len(df)
+        self.df: pl.DataFrame = df[df.columns[self.col_idx]].value_counts(sort=True).sort("count", descending=True)
 
     def on_mount(self) -> None:
         """Create the frequency table."""
@@ -379,9 +393,6 @@ class FrequencyScreen(TableScreen):
         dtype = self.dftable.df.dtypes[self.col_idx]
         dc = DtypeConfig(dtype)
 
-        # Calculate frequencies using Polars
-        total_count = len(self.dftable.df)
-
         # Add column headers with sort indicators
         columns = [
             (column, "Value", 0),
@@ -409,14 +420,14 @@ class FrequencyScreen(TableScreen):
         # Add rows to the frequency table
         for row_idx, row in enumerate(self.df.rows()):
             column, count = row
-            percentage = (count / total_count) * 100
+            percentage = (count / self.total_count) * 100
 
             if column is None:
                 value = NULL_DISPLAY
-            elif dc.gtype == "int" and self.thousand_separator:
+            elif dc.gtype == "integer" and self.thousand_separator:
                 value = f"{column:,}"
             elif dc.gtype == "float":
-                value = f"{column:,.2f}" if self.thousand_separator else f"{column:.3f}"
+                value = format_float(column, self.thousand_separator)
             else:
                 value = str(column)
 
@@ -426,7 +437,7 @@ class FrequencyScreen(TableScreen):
                     f"{count:,}" if self.thousand_separator else str(count), style=ds_int.style, justify=ds_int.justify
                 ),
                 Text(
-                    f"{percentage:,.3f}" if self.thousand_separator else f"{percentage:.3f}",
+                    format_float(percentage, self.thousand_separator),
                     style=ds_float.style,
                     justify=ds_float.justify,
                 ),
@@ -440,8 +451,16 @@ class FrequencyScreen(TableScreen):
         # 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"),
+            Text(
+                f"{self.total_count:,}" if self.thousand_separator else str(self.total_count),
+                style="bold",
+                justify="right",
+            ),
+            Text(
+                format_float(100.0, self.thousand_separator),
+                style="bold",
+                justify="right",
+            ),
             Bar(
                 highlight_range=(0.0, 10),
                 width=10,
@@ -454,12 +473,10 @@ class FrequencyScreen(TableScreen):
         row_idx, col_idx = self.table.cursor_coordinate
         col_sort = col_idx if col_idx == 0 else 1
 
-        sort_dir = self.sorted_columns.get(col_sort)
-        if sort_dir is not None:
+        if self.sorted_columns.get(col_sort) == descending:
             # 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.notify("Already sorted in that order", title="Sort", severity="warning")
+            return
 
         self.sorted_columns.clear()
         self.sorted_columns[col_sort] = descending