Fix all mypy type errors across the codebase

- Remove unused abstract methods (save_state, load_state) from HasState
- Replace Style | None with Style.null() defaults to eliminate union-attr errors
- Add _color_name() helper for safe Color | None access
- Fix type annotations: struct dict params, table_name Path | str, epoch Literal
- Add early return guard in action_iter_search for None-safe queue/idx access
- Use cast() for polars .max() return values in _measure()

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Claude Code

pyproject.toml

@@ -44,17 +44,6 @@ asyncio_mode = "auto"
 
 [tool.mypy]
 ignore_missing_imports = true
-disable_error_code = [
-    "union-attr",
-    "index",
-    "assignment",
-    "attr-defined",
-    "arg-type",
-    "operator",
-    "return-value",
-    "abstract",
-    "type-abstract",
-]
 
 [tool.ruff]
 line-length = 120

src/dt_browser/__init__.py

@@ -35,26 +35,7 @@
 
 
 class HasState:
-    @abstractmethod
-    def save_state(self, existing: dict) -> dict:
-        """
-        Generate any persistent data from this object
-
-        Args:
-            existing: Any existing state for this object which should be merged with the current state.
-            (e.g if there are multiple instances of the browser which should be merged into a single state object)
-        """
-
-    @abstractmethod
-    def load_state(self, state: dict, table_name: str, df: pl.DataFrame):
-        """
-        Apply the provided state to the current object
-
-        Args:
-            state: the state
-            table_name: the current table name being displayed
-            df: The full dataframe being displayed
-        """
+    pass
 
 
 class ReactiveLabel(Label):

src/dt_browser/browser.py

@@ -2,7 +2,7 @@
 import gc
 import pathlib
 import time
-from typing import ClassVar
+from typing import Any, ClassVar, Literal
 
 import click
 import polars as pl
@@ -29,7 +29,7 @@
 )
 from dt_browser.bookmarks import Bookmarks
 from dt_browser.column_selector import ColumnSelector
-from dt_browser.custom_table import CustomTable, polars_list_to_string
+from dt_browser.custom_table import CustomTable, _color_name, polars_list_to_string
 from dt_browser.filter_box import FilterBox
 from dt_browser.save_df_modal import SaveModal
 from dt_browser.suggestor import ColumnNameSuggestor
@@ -72,32 +72,32 @@ class TableWithBookmarks(CustomTable):
     def __init__(self, *args, bookmarks: Bookmarks, **kwargs):
         super().__init__(*args, **kwargs)
         self._bookmarks = bookmarks
-        self._bookmark_highlight: Style | None = None
-        self._search_highlight: Style | None = None
+        self._bookmark_highlight: Style = Style.null()
+        self._search_highlight: Style = Style.null()
 
     def on_mount(self):
         self._bookmark_highlight = self.get_component_rich_style("datatable--row-bookmark")
         self._search_highlight = self.get_component_rich_style("datatable--row-search-result")
 
-    def _get_sel_col_bg_color(self, struct: pl.Struct):
+    def _get_sel_col_bg_color(self, struct: dict[str, Any]) -> str:
         if self.active_search_queue and struct[INDEX_COL] in self.active_search_queue:
-            return self._search_highlight.bgcolor.name
+            return _color_name(self._search_highlight.bgcolor)
         if self._bookmarks.has_bookmarks and struct[INDEX_COL] in self._bookmarks.meta_dt[INDEX_COL]:
-            return self._bookmark_highlight.bgcolor.name
+            return _color_name(self._bookmark_highlight.bgcolor)
         return super()._get_sel_col_bg_color(struct)
 
     def _get_row_bg_color_expr(self, cursor_row_idx: int) -> pl.Expr:
         tmp = super()._get_row_bg_color_expr(cursor_row_idx)
         if self.active_search_queue:
             tmp = (
                 pl.when(pl.col(INDEX_COL).is_in(self.active_search_queue))
-                .then(pl.lit(self._search_highlight.bgcolor.name))
+                .then(pl.lit(_color_name(self._search_highlight.bgcolor)))
                 .otherwise(tmp)
             )
         if self._bookmarks.has_bookmarks:
             tmp = (
                 pl.when(pl.col(INDEX_COL).is_in(self._bookmarks.meta_dt[INDEX_COL]))
-                .then(pl.lit(self._bookmark_highlight.bgcolor.name))
+                .then(pl.lit(_color_name(self._bookmark_highlight.bgcolor)))
                 .otherwise(tmp)
             )
         return tmp
@@ -108,7 +108,8 @@ def _get_row_bg_color_expr(self, cursor_row_idx: int) -> pl.Expr:
 
 def _guess_timestamp_cols(df: pl.DataFrame):
     date_range = pl.Series(values=[datetime.date(2001, 1, 1), datetime.date(2042, 1, 1)])
-    converts = [(x,) + tuple(date_range.dt.epoch(x)) for x in ("s", "ms", "us", "ns")]
+    epoch_units: tuple[Literal["s", "ms", "us", "ns"], ...] = ("s", "ms", "us", "ns")
+    converts = [(x,) + tuple(date_range.dt.epoch(x)) for x in epoch_units]
 
     for col, dtype in df.schema.items():
         if dtype.is_integer():
@@ -342,7 +343,7 @@ class DtBrowser(Widget):  # pylint: disable=too-many-public-methods,too-many-ins
     active_search: reactive[str | None] = reactive(None)
     # active_dt: reactive[pl.DataFrame] = reactive(pl.DataFrame(), init=False, always_update=True)
 
-    def __init__(self, table_name: str, source_file_or_table: pathlib.Path | pl.DataFrame):
+    def __init__(self, table_name: str | pathlib.Path, source_file_or_table: pathlib.Path | pl.DataFrame):
         super().__init__()
         bt = (
             from_file_path(source_file_or_table)
@@ -463,7 +464,7 @@ async def watch_active_search(self, goto: bool = True):
                 if goto:
                     # Find the nearest index to the current cursor
                     coord = self.query_one("#main_table", CustomTable).cursor_coordinate.row
-                    next_row = next((i for i, x in enumerate(self.active_search_queue) if x > coord), None)
+                    next_row = next((i for i, x in enumerate(self.active_search_queue) if x > coord), 0)
                     self.active_search_idx = next_row - 1
                     self.action_iter_search(True)
         except Exception as e:
@@ -472,12 +473,14 @@ async def watch_active_search(self, goto: bool = True):
             foot.search_pending = False
 
     def action_iter_search(self, forward: bool):
+        if self.active_search_queue is None or self.active_search_idx is None:
+            return
         table = self.query_one("#main_table", CustomTable)
         coord = table.cursor_coordinate
         self.active_search_idx = min(
             max(self.active_search_idx + (1 if forward else -1), 0), len(self.active_search_queue) - 1
         )
-        if self.active_search_idx >= 0 and self.active_search_idx < len(self.active_search_queue):
+        if 0 <= self.active_search_idx < len(self.active_search_queue):
             next_idex = self.active_search_queue[self.active_search_idx]
             ys = next_idex
             xs = table.scroll_x
@@ -638,7 +641,7 @@ async def handle_cell_highlight(self, event: CustomTable.CellHighlighted):
     @on(CustomTable.CellSelected, selector="#main_table")
     def handle_cell_select(self, event: CustomTable.CellSelected):
         if self._select_interest:
-            self.query_one(self._select_interest, ReceivesTableSelect).on_table_select(event.value)
+            self.query_one(self._select_interest, ReceivesTableSelect).on_table_select(event.value)  # type: ignore[type-abstract]
             self._select_interest = None
 
     @on(Bookmarks.BookmarkSelected)
@@ -800,7 +803,7 @@ def compose(self) -> ComposeResult:
 
 
 class DtBrowserApp(App):  # pylint: disable=too-many-public-methods,too-many-instance-attributes
-    def __init__(self, table_name: str, source_file_or_table: pathlib.Path | pl.DataFrame):
+    def __init__(self, table_name: str | pathlib.Path, source_file_or_table: pathlib.Path | pl.DataFrame):
         super().__init__()
         self._table_name = table_name
         self._source = source_file_or_table

src/dt_browser/custom_table.py

@@ -10,6 +10,7 @@
 import rich.repr
 from polars.interchange.protocol import Column
 from rich.align import Align
+from rich.color import Color
 from rich.console import Console, RenderableType
 from rich.errors import MarkupError
 from rich.markup import escape
@@ -28,6 +29,11 @@
 from dt_browser import COLOR_COL, COLORS, DISPLAY_IDX_COL, INDEX_COL
 
 
+def _color_name(color: Color | None) -> str:
+    """Extract the name from a Rich Color, defaulting to empty string if None."""
+    return color.name if color is not None else ""
+
+
 def polars_list_to_string(column: pl.Expr):
     return pl.concat_str(pl.lit("["), column.cast(pl.List(pl.String)).list.join(", "), pl.lit("]")).alias(
         column.meta.output_name()
@@ -63,7 +69,7 @@ def cell_formatter(obj: object, null_rep: Text, col: Column | None = None) -> Re
     if isinstance(obj, (float, pl.Decimal)):
         return Align(f"{obj:n}", align="right")
     if isinstance(obj, int):
-        if col is not None and col.is_id:
+        if col is not None and getattr(col, "is_id", False):
             # no separators in ID fields
             return Align(str(obj), align="right")
         return Align(f"{obj:n}", align="right")
@@ -206,9 +212,9 @@ def __init__(
         self._cum_widths: dict[str, int] = {}
         self._formatters: dict[str, pl.Expr] = {}
 
-        self._cell_highlight: Style | None = None
-        self._header_style: Style | None = None
-        self._row_col_highlight: Style | None = None
+        self._cell_highlight: Style = Style.null()
+        self._header_style: Style = Style.null()
+        self._row_col_highlight: Style = Style.null()
 
         self._header: dict[str, Segment] = {}
         self._header_pad: list[Segment] = []
@@ -467,7 +473,7 @@ def on_key(self, event: events.Key) -> None:
     def _build_cast_expr(self, col: str, padding: int = 0):
         dtype = self._dt[col].dtype
         if dtype == pld.Categorical():
-            dtype = pl.Utf8
+            dtype = pl.String()
         as_str = pl.col(col).cast(pl.Utf8).fill_null("")
         if dtype.is_numeric() or dtype.is_temporal():
             return as_str.str.pad_start(padding)
@@ -605,17 +611,17 @@ def _get_row_bg_color_expr(self, cursor_row_idx: int) -> pl.Expr:
             pl.when(pl.col(DISPLAY_IDX_COL) == cursor_row_idx)
             .then(
                 pl.lit(
-                    self._row_col_highlight.bgcolor.name
+                    _color_name(self._row_col_highlight.bgcolor)
                     if self._cursor_type == CustomTable.CursorType.CELL
-                    else self._cell_highlight.bgcolor.name
+                    else _color_name(self._cell_highlight.bgcolor)
                 )
             )
             .otherwise(pl.lit(None))
         )
 
-    def _get_sel_col_bg_color(self, struct: pl.Struct):
+    def _get_sel_col_bg_color(self, struct: dict[str, Any]):
         return (
-            self._row_col_highlight.bgcolor.name
+            _color_name(self._row_col_highlight.bgcolor)
             if self._cursor_type == CustomTable.CursorType.CELL
             else struct["bgcolor"]
         )
@@ -644,7 +650,7 @@ def _gen_segments(self, lines: list[int] | None):
                         PADDING_STR,
                         style=Style(
                             color=(
-                                self._cell_highlight.color.name
+                                _color_name(self._cell_highlight.color)
                                 if (
                                     self._cursor_type == CustomTable.CursorType.ROW
                                     and struct[DISPLAY_IDX_COL] == cursor_row_idx
@@ -658,7 +664,7 @@ def _gen_segments(self, lines: list[int] | None):
                         struct["before_selected"],
                         style=Style(
                             color=(
-                                self._cell_highlight.color.name
+                                _color_name(self._cell_highlight.color)
                                 if (
                                     self._cursor_type == CustomTable.CursorType.ROW
                                     and struct[DISPLAY_IDX_COL] == cursor_row_idx
@@ -672,12 +678,12 @@ def _gen_segments(self, lines: list[int] | None):
                         struct["selected"],
                         style=Style(
                             color=(
-                                self._cell_highlight.color.name
+                                _color_name(self._cell_highlight.color)
                                 if struct[DISPLAY_IDX_COL] == cursor_row_idx
                                 else struct[COLOR_COL]
                             ),
                             bgcolor=(
-                                self._cell_highlight.bgcolor.name
+                                _color_name(self._cell_highlight.bgcolor)
                                 if struct[DISPLAY_IDX_COL] == cursor_row_idx
                                 else self._get_sel_col_bg_color(struct)
                             ),
@@ -687,7 +693,7 @@ def _gen_segments(self, lines: list[int] | None):
                         struct["after_selected"],
                         style=Style(
                             color=(
-                                self._cell_highlight.color.name
+                                _color_name(self._cell_highlight.color)
                                 if (
                                     self._cursor_type == CustomTable.CursorType.ROW
                                     and struct[DISPLAY_IDX_COL] == cursor_row_idx
@@ -758,11 +764,11 @@ def _measure(self, arr: pl.Series) -> int:
 
         if isinstance(dtype, pl.Array):
             base = arr.arr.eval(pl.element().cast(pl.String).str.len_chars())
-            return (base.arr.sum() + (base.arr.len() - 1) * len(", ") + 2).max()
+            return cast(int, (base.arr.sum() + (base.arr.len() - 1) * len(", ") + 2).max())
 
         if isinstance(dtype, pl.List):
             base = arr.list.eval(pl.element().cast(pl.String).str.len_chars())
-            return (base.list.sum() + (base.list.len() - 1) * len(", ") + 2).max()
+            return cast(int, (base.list.sum() + (base.list.len() - 1) * len(", ") + 2).max())
 
         if dtype.is_integer():
             col_max = arr.max()

src/dt_browser/filter_box.py

@@ -107,7 +107,7 @@ def get_value(self):
     @on(ListView.Selected)
     def input_historical(self, event: ListView.Selected):
         box = self.query_one(Input)
-        box.value = event.item.name
+        box.value = event.item.name or ""
         box.focus()
 
     def key_down(self):