style: apply ruff format to src, tests, and plugins

Reformat 10 files to comply with ruff format checks:
- Split long function arguments across multiple lines
- Merge unnecessarily split short strings
- Use parenthesized with-statements for multiple context managers
- Remove extra blank lines and adjust indentation

No logic changes. All 618 tests still pass.

Author: sunbos

plugins/mcp-server-sqlseed/src/mcp_server_sqlseed/server.py

@@ -347,8 +347,7 @@ def sqlseed_list_gemma_models() -> dict[str, Any]:
         return {
             "models": [],
             "backends": [
-                {"id": bid, "description": desc, "available": False}
-                for bid, desc in backend_descriptions.items()
+                {"id": bid, "description": desc, "available": False} for bid, desc in backend_descriptions.items()
             ],
             "hardware": {},
             "error": "sqlseed-ai plugin not installed. Install with: pip install sqlseed-ai",
@@ -363,12 +362,14 @@ def sqlseed_list_gemma_models() -> dict[str, Any]:
 
     # Google AI Studio: check API key
     has_api_key = ai_config.has_real_api_key
-    backends_result.append({
-        "id": "google_ai_studio",
-        "description": backend_descriptions["google_ai_studio"],
-        "available": has_api_key,
-        "reason": "API key configured" if has_api_key else "No API key (set GOOGLE_API_KEY or SQLSEED_AI_API_KEY)",
-    })
+    backends_result.append(
+        {
+            "id": "google_ai_studio",
+            "description": backend_descriptions["google_ai_studio"],
+            "available": has_api_key,
+            "reason": "API key configured" if has_api_key else "No API key (set GOOGLE_API_KEY or SQLSEED_AI_API_KEY)",
+        }
+    )
 
     # LM Studio / Ollama: check service reachability + loaded models
     local_urls: dict[str, str] = {
@@ -394,22 +395,26 @@ def sqlseed_list_gemma_models() -> dict[str, Any]:
         else:
             reason = "Service not running"
 
-        backends_result.append({
-            "id": backend_id,
-            "description": backend_descriptions[backend_id],
-            "available": reachable and bool(loaded),
-            "reachable": reachable,
-            "loaded_models": loaded,
-            "reason": reason,
-        })
+        backends_result.append(
+            {
+                "id": backend_id,
+                "description": backend_descriptions[backend_id],
+                "available": reachable and bool(loaded),
+                "reachable": reachable,
+                "loaded_models": loaded,
+                "reason": reason,
+            }
+        )
 
     # OpenAI-compatible: informational only
-    backends_result.append({
-        "id": "openai_compat",
-        "description": backend_descriptions["openai_compat"],
-        "available": False,
-        "reason": "Requires explicit base_url configuration",
-    })
+    backends_result.append(
+        {
+            "id": "openai_compat",
+            "description": backend_descriptions["openai_compat"],
+            "available": False,
+            "reason": "Requires explicit base_url configuration",
+        }
+    )
 
     # ── 3. Build model list with compatibility status ──
     status_icons: dict[str, str] = {
@@ -425,18 +430,20 @@ def sqlseed_list_gemma_models() -> dict[str, Any]:
     for member in GemmaModel:
         status = evaluate_model_status(member.value, hw)
         model_req = MODEL_REQUIREMENTS.get(member.value, {})
-        models.append({
-            "id": member.value,
-            "display_name": member.display_name,
-            "status": status,
-            "status_description": status_icons.get(status, status),
-            "local_only": member.is_local_only,
-            "requirements": {
-                "min_ram_gb": model_req.get("min_ram_gb", 0),
-                "min_vram_gb": model_req.get("min_vram_gb", 0),
-                "recommended_vram_gb": model_req.get("recommended_vram_gb", 0),
-            },
-        })
+        models.append(
+            {
+                "id": member.value,
+                "display_name": member.display_name,
+                "status": status,
+                "status_description": status_icons.get(status, status),
+                "local_only": member.is_local_only,
+                "requirements": {
+                    "min_ram_gb": model_req.get("min_ram_gb", 0),
+                    "min_vram_gb": model_req.get("min_vram_gb", 0),
+                    "recommended_vram_gb": model_req.get("recommended_vram_gb", 0),
+                },
+            }
+        )
 
     # ── 4. Determine best default ──
     # Pick the largest capable model (iterate from largest to smallest)

plugins/sqlseed-ai/src/sqlseed_ai/_hardware.py

@@ -5,6 +5,7 @@
 
 Supported platforms: Windows, Linux, macOS (Intel + Apple Silicon).
 """
+
 from __future__ import annotations
 
 import ctypes
@@ -30,9 +31,11 @@ class _HardwareCache:
 
 # ── System RAM ───────────────────────────────────────────────────────
 
+
 def _get_ram_windows() -> tuple[float, float] | None:
     """Get RAM via Win32 API (ctypes). Returns (total_gb, available_gb)."""
     try:
+
         class MEMORYSTATUSEX(ctypes.Structure):
             _fields_ = [
                 ("dwLength", ctypes.c_ulong),
@@ -78,7 +81,10 @@ def _get_ram_macos() -> tuple[float, float] | None:
     try:
         result = subprocess.run(
             ["sysctl", "-n", "hw.memsize"],
-            capture_output=True, text=True, timeout=5, check=False,
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
         )
         if result.returncode != 0 or not result.stdout:
             return None
@@ -87,7 +93,11 @@ def _get_ram_macos() -> tuple[float, float] | None:
 
         avail_gb = 0.0
         result = subprocess.run(
-            ["vm_stat"], capture_output=True, text=True, timeout=5, check=False,
+            ["vm_stat"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
         )
         if result.returncode == 0 and result.stdout:
             # Default page size: Apple Silicon = 16384, Intel Mac = 4096
@@ -124,6 +134,7 @@ def _detect_system_ram() -> dict[str, Any]:
 
 # ── GPU / VRAM ───────────────────────────────────────────────────────
 
+
 def _detect_gpu_nvidia() -> list[dict[str, Any]]:
     """Detect NVIDIA GPUs via nvidia-smi (works on all platforms)."""
     try:
@@ -133,7 +144,10 @@ def _detect_gpu_nvidia() -> list[dict[str, Any]]:
                 "--query-gpu=name,memory.total,memory.free,driver_version",
                 "--format=csv,noheader,nounits",
             ],
-            capture_output=True, text=True, timeout=5, check=False,
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
         )
         if result.returncode != 0 or not result.stdout:
             return []
@@ -144,14 +158,16 @@ def _detect_gpu_nvidia() -> list[dict[str, Any]]:
             if len(parts) >= 4:
                 vram_total = int(parts[1])
                 vram_free = int(parts[2])
-                gpus.append({
-                    "name": parts[0],
-                    "vram_total_mb": vram_total,
-                    "vram_free_mb": vram_free,
-                    "vram_total_gb": round(vram_total / 1024, 1),
-                    "driver_version": parts[3],
-                    "vendor": "nvidia",
-                })
+                gpus.append(
+                    {
+                        "name": parts[0],
+                        "vram_total_mb": vram_total,
+                        "vram_free_mb": vram_free,
+                        "vram_total_gb": round(vram_total / 1024, 1),
+                        "driver_version": parts[3],
+                        "vendor": "nvidia",
+                    }
+                )
         return gpus
     except (FileNotFoundError, subprocess.TimeoutExpired, ValueError):
         return []
@@ -162,7 +178,10 @@ def _detect_gpu_macos() -> list[dict[str, Any]]:
     try:
         result = subprocess.run(
             ["system_profiler", "SPDisplaysDataType", "-json"],
-            capture_output=True, text=True, timeout=10, check=False,
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
         )
         if result.returncode != 0 or not result.stdout:
             return []
@@ -181,13 +200,15 @@ def _detect_gpu_macos() -> list[dict[str, Any]]:
                     unit = parts[1].upper()
                     vram_mb = val * 1024 if "GB" in unit else val
 
-            gpus.append({
-                "name": name,
-                "vram_total_mb": vram_mb,
-                "vram_free_mb": 0,  # Apple Silicon uses unified memory; discrete VRAM is always 0
-                "vram_total_gb": round(vram_mb / 1024, 1),
-                "vendor": "apple",
-            })
+            gpus.append(
+                {
+                    "name": name,
+                    "vram_total_mb": vram_mb,
+                    "vram_free_mb": 0,  # Apple Silicon uses unified memory; discrete VRAM is always 0
+                    "vram_total_gb": round(vram_mb / 1024, 1),
+                    "vendor": "apple",
+                }
+            )
         return gpus
     except (FileNotFoundError, json.JSONDecodeError, subprocess.TimeoutExpired, ValueError):
         return []
@@ -207,6 +228,7 @@ def _detect_gpus() -> list[dict[str, Any]]:
 
 # ── Public API ───────────────────────────────────────────────────────
 
+
 def detect_hardware() -> dict[str, Any]:
     """Detect hardware environment. Results are cached for 5 minutes.
 

src/sqlseed/core/enrichment.py

@@ -147,6 +147,7 @@ def _build_enriched_spec(
         if self.is_enumeration_column(col_name, col_info, distinct_count, row_count, is_unique):
             choices = distinct_values
             if col_info and "INT" in col_info.type.upper():
+
                 def _safe_int(v: Any) -> Any:
                     if isinstance(v, (int, float)):
                         return int(v)

src/sqlseed/core/mapper.py

@@ -303,7 +303,11 @@ def map_column(
                 return snake_pattern
 
         fallback_spec = self._map_from_default(
-            column_info, column_type, enrich, force_type_infer, include_nullable=True,
+            column_info,
+            column_type,
+            enrich,
+            force_type_infer,
+            include_nullable=True,
         )
         if fallback_spec:
             return fallback_spec

src/sqlseed/core/orchestrator.py

@@ -565,7 +565,11 @@ def get_column_mapping(self, table_name: str) -> dict[str, Any]:
         """
         self._ensure_connected()
         specs, _, _ = self._resolve_specs(
-            table_name, count=1, columns=None, column_configs=None, enrich=False,
+            table_name,
+            count=1,
+            columns=None,
+            column_configs=None,
+            enrich=False,
         )
         return specs
 

src/sqlseed/generators/_dispatch.py

@@ -57,7 +57,6 @@ def verify_dispatch_sync() -> None:
             import warnings  # noqa: PLC0415
 
             warnings.warn(
-                f"GENERATOR_MAP['{gen_name}'] references '{method_name}' "
-                f"which does not exist on BaseProvider",
+                f"GENERATOR_MAP['{gen_name}'] references '{method_name}' which does not exist on BaseProvider",
                 stacklevel=1,
             )

src/sqlseed/generators/base_provider.py

@@ -354,8 +354,7 @@ def _gen_pattern(self, *, pattern: str | None = None, regex: str | None = None)
             import rstr as _rstr  # noqa: PLC0415
         except ImportError as err:
             raise ImportError(
-                "The 'rstr' package is required for pattern generation. "
-                "Install it with: pip install rstr"
+                "The 'rstr' package is required for pattern generation. Install it with: pip install rstr"
             ) from err
         r = _rstr.Rstr(self._rng)
         return r.xeger(effective)

tests/test_doc_sync.py

@@ -56,7 +56,6 @@ def _find_marker_claims(marker_name: str) -> list[tuple[Path, str]]:
     return claims
 
 
-
 def _find_doc_files() -> list[Path]:
     """Collect all .md files that may contain code-derived facts."""
     candidates = [
@@ -276,14 +275,7 @@ def _get_mcp_tool_names() -> list[str]:
 
     Looks for @mcp.tool() decorated functions.
     """
-    code = _read(
-        ROOT
-        / "plugins"
-        / "mcp-server-sqlseed"
-        / "src"
-        / "mcp_server_sqlseed"
-        / "server.py"
-    )
+    code = _read(ROOT / "plugins" / "mcp-server-sqlseed" / "src" / "mcp_server_sqlseed" / "server.py")
     tools: list[str] = []
     lines = code.splitlines()
     for i, line in enumerate(lines):
@@ -424,8 +416,7 @@ def test_count_in_docs(self):
         )
         for doc_path, value in marker_claims:
             assert int(value) == rule_count, (
-                f"{doc_path}: marker claims {value} exact-match rules, "
-                f"but EXACT_MATCH_RULES has {rule_count}"
+                f"{doc_path}: marker claims {value} exact-match rules, but EXACT_MATCH_RULES has {rule_count}"
             )
 
         # Secondary protection: keyword-based search for unmarked claims.
@@ -545,8 +536,7 @@ def test_count_in_docs(self):
         )
         for doc_path, value in marker_claims:
             assert int(value) == rule_count, (
-                f"{doc_path}: marker claims {value} pattern-match rules, "
-                f"but PATTERN_MATCH_RULES has {rule_count}"
+                f"{doc_path}: marker claims {value} pattern-match rules, but PATTERN_MATCH_RULES has {rule_count}"
             )
 
         # Secondary protection: keyword-based search for unmarked claims.
@@ -572,9 +562,7 @@ def test_count_in_docs(self):
             text = _read(doc_path)
             matches = _extract_number_before_keyword(text, ["个枚举", "enum pattern", "enum name"])
             for m in matches:
-                assert int(m) == count, (
-                    f"{doc_path}: claims {m} enum patterns, but ENUM_NAME_PATTERNS has {count}"
-                )
+                assert int(m) == count, f"{doc_path}: claims {m} enum patterns, but ENUM_NAME_PATTERNS has {count}"
 
 
 class TestMcpToolNames:
@@ -584,9 +572,7 @@ def test_tools_documented(self):
         tools = _get_mcp_tool_names()
         readme = _read(ROOT / "plugins" / "mcp-server-sqlseed" / "README.md")
         for tool in tools:
-            assert tool in readme, (
-                f"MCP tool '{tool}' not mentioned in mcp-server-sqlseed README.md"
-            )
+            assert tool in readme, f"MCP tool '{tool}' not mentioned in mcp-server-sqlseed README.md"
 
 
 class TestAutoGeneratedMarkers:
@@ -602,6 +588,4 @@ def test_markers_balanced(self):
             text = _read(doc_path)
             begins = text.count("<!-- BEGIN:AUTO-GENERATED")
             ends = text.count("<!-- END:AUTO-GENERATED")
-            assert begins == ends, (
-                f"{doc_path}: {begins} BEGIN markers but {ends} END markers"
-            )
+            assert begins == ends, f"{doc_path}: {begins} BEGIN markers but {ends} END markers"

tests/test_generators/test_dispatch_sync.py

@@ -1,4 +1,5 @@
 """Verify GENERATOR_MAP stays in sync with BaseProvider methods."""
+
 from __future__ import annotations
 
 import warnings