Fix several lint issues and improve CI workflow

Author: carmiac

.github/workflows/ci.yml

@@ -24,6 +24,9 @@ jobs:
       - name: Install dependencies
         run: pip install -e ".[dev]"
 
+      - name: Lint
+        run: ruff check src/ tests/
+
       - name: Run tests
         run: pytest
 

src/tca/__init__.py

@@ -1,27 +1,27 @@
 """Terminal Colors Architecture (TCA) theme support for Python."""
 
-from importlib.metadata import version, PackageNotFoundError
+from importlib.metadata import PackageNotFoundError, version
 
-from .theme import (
-    Theme,
-    Meta,
-    ANSI,
-    Semantic,
-    UI,
-    Base16,
-    ColorRamp,
-)
 from .loader import (
+    find_theme,
     get_data_dir,
     get_themes_dir,
     list_theme_files,
     list_theme_names,
-    find_theme,
     load_theme,
     load_theme_file,
     load_theme_from_path,
     load_themes_from_dir,
 )
+from .theme import (
+    ANSI,
+    UI,
+    Base16,
+    ColorRamp,
+    Meta,
+    Semantic,
+    Theme,
+)
 
 try:
     __version__ = version("tca-python")

src/tca/loader.py

@@ -2,6 +2,7 @@
 
 import warnings
 from pathlib import Path
+
 import platformdirs
 
 from .theme import Theme

src/tca/textual.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from .theme import Theme
 
@@ -17,7 +17,7 @@ def _color(hex_str: str) -> Color:
     return _Color.parse(hex_str)
 
 
-def _color_system(**kwargs) -> ColorSystem:
+def _color_system(**kwargs: Any) -> ColorSystem:
     from textual.design import ColorSystem as _ColorSystem
     return _ColorSystem(**kwargs)
 
@@ -31,7 +31,7 @@ class TextualTheme(Theme):
     """
 
     @classmethod
-    def from_theme(cls, theme: Theme) -> "TextualTheme":
+    def from_theme(cls, theme: Theme) -> TextualTheme:
         """Create a TextualTheme from a Theme object."""
         from dataclasses import fields as _fields
         return cls(**{f.name: getattr(theme, f.name) for f in _fields(Theme)})
@@ -65,7 +65,7 @@ def ui_color(self, name: str) -> Color:
         """Get UI color by name as Textual Color."""
         return _color(getattr(self.ui, name))
 
-    def get_palette_ramp(self, name: str) -> dict[int, Color]:
+    def get_palette_ramp(self, name: str) -> dict[int, Color]:  # type: ignore[override]
         """Get palette ramp as a dict of index to Textual Color."""
         ramp = super().get_palette_ramp(name)
         return {tone: _color(color) for tone, color in ramp.items()}

src/tca/theme.py

@@ -3,24 +3,28 @@
 from __future__ import annotations
 
 import sys
+from collections.abc import Iterator
 from dataclasses import dataclass, fields
-from typing import Any
+from typing import Any, TypeVar
 
 if sys.version_info >= (3, 11):
     import tomllib
 else:
-    import tomli as tomllib  # type: ignore[no-redef]
+    import tomli as tomllib
 
 
 # ---------------------------------------------------------------------------
 # Shared mixin for _Raw* data classes
 # ---------------------------------------------------------------------------
 
+_T = TypeVar("_T", bound="_FromDictMixin")
+
+
 class _FromDictMixin:
     """Mixin providing a generic from_dict classmethod for dataclasses."""
 
     @classmethod
-    def from_dict(cls, d: dict[str, Any]):
+    def from_dict(cls: type[_T], d: dict[str, Any]) -> _T:
         known = {f.name for f in fields(cls)}  # type: ignore[arg-type]
         return cls(**{k: v for k, v in d.items() if k in known})
 
@@ -90,7 +94,7 @@ class _RawUI:
     selection_fg: str | None = None
 
     @classmethod
-    def from_dict(cls, d: dict[str, Any]) -> "_RawUI":
+    def from_dict(cls, d: dict[str, Any]) -> _RawUI:
         """Build from a nested dict as produced by TOML [ui.bg], [ui.fg], etc."""
         field_names = {f.name for f in fields(cls)}
         flat: dict[str, str] = {}
@@ -126,7 +130,7 @@ class _RawBase16:
     base0f: str | None = None
 
     @classmethod
-    def from_dict(cls, d: dict[str, Any]) -> "_RawBase16":
+    def from_dict(cls, d: dict[str, Any]) -> _RawBase16:
         field_names = {f.name for f in fields(cls)}
         # Normalise keys to lowercase (spec examples show base0A etc.)
         normalised = {k.lower(): v for k, v in d.items()}
@@ -153,7 +157,7 @@ def __len__(self) -> int:
     def __getitem__(self, index: int) -> str:
         return self.colors[index]
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[str]:
         return iter(self.colors)
 
 
@@ -262,7 +266,7 @@ class Theme:
     base16: Base16
 
     @classmethod
-    def _from_raw(cls, raw: "_RawTheme") -> "Theme":
+    def _from_raw(cls, raw: _RawTheme) -> Theme:
         meta = raw.resolve_meta()
         palette = raw.resolve_palette()
         ansi = raw.resolve_ansi()
@@ -284,12 +288,12 @@ def get_palette_ramp(self, name: str) -> dict[int, str]:
         return {i: color for i, color in enumerate(ramp.colors)}
 
     @classmethod
-    def from_toml(cls, data_str: str) -> "Theme":
+    def from_toml(cls, data_str: str) -> Theme:
         raw = _RawTheme.from_toml(data_str)
         return cls._from_raw(raw)
 
     @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "Theme":
+    def from_dict(cls, data: dict[str, Any]) -> Theme:
         raw = _RawTheme.from_dict(data)
         return cls._from_raw(raw)
 
@@ -505,14 +509,14 @@ def _is_dark(self) -> bool:
     # ------------------------------------------------------------------
 
     @classmethod
-    def from_toml(cls, data_str: str) -> "_RawTheme":
+    def from_toml(cls, data_str: str) -> _RawTheme:
         data = tomllib.loads(data_str)
         if not data:
             raise ValueError("Empty theme file")
         return cls.from_dict(data)
 
     @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "_RawTheme":
+    def from_dict(cls, data: dict[str, Any]) -> _RawTheme:
         # --- [theme] section (required) ---
         theme_dict = data.get("theme", {})
         theme_meta = _RawThemeMeta.from_dict(theme_dict)

tests/test_theme.py

@@ -1,10 +1,11 @@
 """Tests for TCA theme loading and resolution."""
 
+from pathlib import Path
+
 import pytest
+
 from tca import load_theme, load_theme_from_path, load_themes_from_dir
 from tca.theme import Theme
-from pathlib import Path
-
 
 DRACULA_PATH = Path(__file__).parent / "dracula.toml"
 THEMES_DIR = Path(__file__).parent
@@ -68,7 +69,7 @@ def test_ansi_normal_colors():
 
 
 def test_ansi_bright_colors():
-    """Bright ANSI colours (brightBlack in YAML → bright_black in Python) are resolved."""
+    """Bright ANSI colours (e.g. bright_black) are populated and valid."""
     theme = load_theme(DRACULA_PATH)
     assert theme.ansi.bright_black is not None
     assert theme.ansi.bright_black.startswith("#")