Add black formatting check to CI lint workflow

Add black>=26.3.1 to test dependencies and a lint-black job to the
lint workflow. Adjust ruff isort config for black compatibility:
add force-sort-within-sections and remove lines-after-imports=2.

Author: lukekim

.github/workflows/lint.yml

@@ -84,6 +84,27 @@ jobs:
         run: |
           mypy spicepy --ignore-missing-imports
 
+  lint-black:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.11', '3.12', '3.13', '3.14']
+    name: Lint with black (Python ${{ matrix.python-version }})
+    steps:
+      - uses: actions/checkout@v6
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          cache: 'pip'
+      - name: Install requirements
+        run: |
+          pip install ".[test]"
+      - name: Check formatting with black
+        run: |
+          black --check spicepy tests
+
   security-check:
     runs-on: ubuntu-latest
     name: Security scan with bandit

pyproject.toml

@@ -50,6 +50,7 @@ test = [
     "pytest_httpserver==1.1.5",
     "types-requests>=2.33.0",
     "pandas-stubs>=3.0.0",
+    "black>=26.3.1",
     "bandit>=1.9.4",
     "pandas>=3.0.2",
     "pyarrow>=23.0.1",
@@ -189,7 +190,7 @@ ignore = [
 [tool.ruff.lint.isort]
 known-first-party = ["spicepy"]
 force-single-line = false
-lines-after-imports = 2
+force-sort-within-sections = true
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

spicepy/_client.py

@@ -1,8 +1,8 @@
 import json
 import os
+from pathlib import Path
 import platform
 import threading
-from pathlib import Path
 from typing import Any
 
 import certifi
@@ -21,7 +21,10 @@
 
 
 def is_macos_arm64() -> bool:
-    return platform.platform().lower().startswith("macos") and platform.machine() == "arm64"
+    return (
+        platform.platform().lower().startswith("macos")
+        and platform.machine() == "arm64"
+    )
 
 
 try:
@@ -85,7 +88,9 @@ def _init_connection(self):
         # Add authentication if API key provided
         if self._api_key:
             db_kwargs[adbc_driver_manager.DatabaseOptions.USERNAME.value] = ""
-            db_kwargs[adbc_driver_manager.DatabaseOptions.PASSWORD.value] = self._api_key
+            db_kwargs[adbc_driver_manager.DatabaseOptions.PASSWORD.value] = (
+                self._api_key
+            )
 
         # Create low-level database and connection (avoids dbapi autocommit warning)
         self._db = adbc_driver_flightsql.connect(self._uri, db_kwargs=db_kwargs)
@@ -110,7 +115,11 @@ def _create_param_batch(
 
         for param in params:
             # Check if param is a tuple of (value, arrow_type)
-            if isinstance(param, tuple) and len(param) == 2 and isinstance(param[1], pa.DataType):
+            if (
+                isinstance(param, tuple)
+                and len(param) == 2
+                and isinstance(param[1], pa.DataType)
+            ):
                 value, arrow_type = param
                 param_values.append(value)
                 param_types.append(arrow_type)
@@ -124,7 +133,9 @@ def _create_param_batch(
             param_arrays.append(pa.array([value], type=arrow_type))
 
         # Create parameter schema with positional field names ($1, $2, etc.)
-        param_fields = [pa.field(f"${i + 1}", param_types[i]) for i in range(len(params))]
+        param_fields = [
+            pa.field(f"${i + 1}", param_types[i]) for i in range(len(params))
+        ]
         param_schema = pa.schema(param_fields)
 
         return pa.record_batch(param_arrays, schema=param_schema)
@@ -189,7 +200,11 @@ def __init__(
         tls_root_cert,
     ):
         if tls_root_cert is not None:
-            tls_root_cert = tls_root_cert if isinstance(tls_root_cert, Path) else Path(tls_root_cert)
+            tls_root_cert = (
+                tls_root_cert
+                if isinstance(tls_root_cert, Path)
+                else Path(tls_root_cert)
+            )
         else:
             tls_root_cert = Path(certifi.where())
 
@@ -208,14 +223,19 @@ def _user_agent(custom_user_agent=None):
 
         # Prepend the custom user agent (if provided) to the default user agent
         if custom_user_agent:
-            return (str.encode("user-agent"), str.encode(f"{custom_user_agent} {config.SPICE_USER_AGENT}"))
+            return (
+                str.encode("user-agent"),
+                str.encode(f"{custom_user_agent} {config.SPICE_USER_AGENT}"),
+            )
         return (str.encode("user-agent"), str.encode(config.SPICE_USER_AGENT))
 
     def __init__(self, grpc: str, api_key: str, tls_root_certs, user_agent=None):
         self._flight_client = flight.connect(grpc, tls_root_certs=tls_root_certs)
         self._api_key = api_key
         self.headers = [_SpiceFlight._user_agent(user_agent)]
-        self._flight_options = flight.FlightCallOptions(headers=self.headers, timeout=DEFAULT_QUERY_TIMEOUT_SECS)
+        self._flight_options = flight.FlightCallOptions(
+            headers=self.headers, timeout=DEFAULT_QUERY_TIMEOUT_SECS
+        )
         self._authenticate()
 
     def _authenticate(self):
@@ -224,30 +244,42 @@ def _authenticate(self):
                 self._flight_client.authenticate_basic_token("", self._api_key),
                 _SpiceFlight._user_agent(),
             ]
-            self._flight_options = flight.FlightCallOptions(headers=self.headers, timeout=DEFAULT_QUERY_TIMEOUT_SECS)
+            self._flight_options = flight.FlightCallOptions(
+                headers=self.headers, timeout=DEFAULT_QUERY_TIMEOUT_SECS
+            )
         else:
             self.headers = [_SpiceFlight._user_agent()]
-            self._flight_options = flight.FlightCallOptions(headers=self.headers, timeout=DEFAULT_QUERY_TIMEOUT_SECS)
+            self._flight_options = flight.FlightCallOptions(
+                headers=self.headers, timeout=DEFAULT_QUERY_TIMEOUT_SECS
+            )
 
     def query(self, query: str, **kwargs) -> flight.FlightStreamReader:
         timeout = kwargs.get("timeout")
 
         if timeout is not None:
             if not isinstance(timeout, int) or timeout <= 0:
                 raise ValueError("Timeout must be a positive integer")
-            self._flight_options = flight.FlightCallOptions(headers=self.headers, timeout=timeout)
+            self._flight_options = flight.FlightCallOptions(
+                headers=self.headers, timeout=timeout
+            )
 
         flight_info = self._flight_client.get_flight_info(
             flight.FlightDescriptor.for_command(query), self._flight_options
         )
 
         try:
-            reader = self._threaded_flight_do_get(ticket=flight_info.endpoints[0].ticket)
+            reader = self._threaded_flight_do_get(
+                ticket=flight_info.endpoints[0].ticket
+            )
         except flight.FlightUnauthenticatedError:
             self._authenticate()
-            reader = self._threaded_flight_do_get(ticket=flight_info.endpoints[0].ticket)
+            reader = self._threaded_flight_do_get(
+                ticket=flight_info.endpoints[0].ticket
+            )
         except flight.FlightTimedOutError as exc:
-            raise TimeoutError(f"Query timed out and was canceled after {timeout} seconds.") from exc
+            raise TimeoutError(
+                f"Query timed out and was canceled after {timeout} seconds."
+            ) from exc
 
         return reader
 
@@ -275,7 +307,9 @@ def __init__(
         user_agent: str | None = None,
     ):  # pylint: disable=R0913
         tls_root_certs = _Cert(tls_root_cert).tls_root_certs
-        self._flight = _SpiceFlight(flight_url, api_key or "", tls_root_certs, user_agent)
+        self._flight = _SpiceFlight(
+            flight_url, api_key or "", tls_root_certs, user_agent
+        )
 
         self.api_key = api_key
         self._flight_url = flight_url
@@ -369,15 +403,23 @@ def query_with_params(
             ValueError: If params is None
         """
         if params is None:
-            raise ValueError("params must be a list, not None. Use [] for queries without parameters.")
+            raise ValueError(
+                "params must be a list, not None. Use [] for queries without parameters."
+            )
         adbc = self._ensure_adbc_client()
         return adbc.query_with_params(sql, params)
 
-    def refresh_dataset(self, dataset: str, refresh_opts: RefreshOpts | None = None) -> Any:
+    def refresh_dataset(
+        self, dataset: str, refresh_opts: RefreshOpts | None = None
+    ) -> Any:
         response = self.http.send_request(
             "POST",
             f"/v1/datasets/{dataset}/acceleration/refresh",
-            body=(json.dumps(refresh_opts.to_dict()) if refresh_opts is not None else json.dumps({})),
+            body=(
+                json.dumps(refresh_opts.to_dict())
+                if refresh_opts is not None
+                else json.dumps({})
+            ),
             headers={"Content-Type": "application/json"},
         )
 

spicepy/_http.py

@@ -1,6 +1,6 @@
-import datetime
 from collections.abc import Callable
 from dataclasses import dataclass
+import datetime
 from typing import Any, Literal
 
 from requests import Response, Session

spicepy/config.py

@@ -1,12 +1,13 @@
+from importlib.metadata import version
 import os
 import platform
-from importlib.metadata import version
-
 
 DEFAULT_FLIGHT_URL = os.environ.get("SPICE_FLIGHT_URL", "grpc+tls://flight.spiceai.io")
 DEFAULT_HTTP_URL = os.environ.get("SPICE_HTTP_URL", "https://data.spiceai.io")
 
-DEFAULT_LOCAL_FLIGHT_URL = os.environ.get("SPICE_LOCAL_FLIGHT_URL", "grpc://localhost:50051")
+DEFAULT_LOCAL_FLIGHT_URL = os.environ.get(
+    "SPICE_LOCAL_FLIGHT_URL", "grpc://localhost:50051"
+)
 DEFAULT_LOCAL_HTTP_URL = os.environ.get("SPICE_LOCAL_HTTP_URL", "http://localhost:8090")
 
 
@@ -19,7 +20,9 @@
 #   Default is the system information of the current system, e.g. `Linux/5.4.0-1043-aws x86_64`.
 ###
 def get_user_agent(
-    client_name: str | None = None, client_version: str | None = None, client_system: str | None = None
+    client_name: str | None = None,
+    client_version: str | None = None,
+    client_system: str | None = None,
 ) -> str:
     package_version = version("spicepy") if client_version is None else client_version
     system = platform.system()
@@ -28,7 +31,9 @@ def get_user_agent(
     if arch == "AMD64":
         arch = "x86_64"
 
-    system_info = f"{system}/{release} {arch}" if client_system is None else client_system
+    system_info = (
+        f"{system}/{release} {arch}" if client_system is None else client_system
+    )
     client = "spicepy" if client_name is None else client_name
     return f"{client}/{package_version} ({system_info})"
 

tests/conftest.py

@@ -2,21 +2,26 @@
 
 from __future__ import annotations
 
-import os
 from collections.abc import Generator
+import os
 from unittest.mock import MagicMock, patch
 
 import pytest
 
-
 # ============== Markers ==============
 
 
 def pytest_configure(config: pytest.Config) -> None:
     """Register custom markers."""
-    config.addinivalue_line("markers", "unit: Unit tests that don't require external services")
-    config.addinivalue_line("markers", "integration: Integration tests that require Spice runtime")
-    config.addinivalue_line("markers", "cloud: Tests that require Spice.ai cloud connection")
+    config.addinivalue_line(
+        "markers", "unit: Unit tests that don't require external services"
+    )
+    config.addinivalue_line(
+        "markers", "integration: Integration tests that require Spice runtime"
+    )
+    config.addinivalue_line(
+        "markers", "cloud: Tests that require Spice.ai cloud connection"
+    )
     config.addinivalue_line("markers", "slow: Tests that take a long time to run")
 
 
@@ -55,7 +60,9 @@ def is_adbc_available() -> bool:
         return False
 
 
-skip_if_no_adbc = pytest.mark.skipif(not is_adbc_available(), reason="ADBC driver not installed")
+skip_if_no_adbc = pytest.mark.skipif(
+    not is_adbc_available(), reason="ADBC driver not installed"
+)
 
 
 # ============== Mock Fixtures ==============

tests/test_client.py

@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 import os
-import threading
 from pathlib import Path
+import threading
 from unittest.mock import MagicMock, patch
 
 import pyarrow as pa
@@ -98,7 +98,10 @@ def test_client_with_custom_urls(
         mock_cert.tls_root_certs = b"cert"
         mock_cert_class.return_value = mock_cert
 
-        client = Client(flight_url="grpc+tls://custom.spiceai.io", http_url="https://custom-data.spiceai.io")
+        client = Client(
+            flight_url="grpc+tls://custom.spiceai.io",
+            http_url="https://custom-data.spiceai.io",
+        )
 
         assert client._flight_url == "grpc+tls://custom.spiceai.io"
 
@@ -340,7 +343,9 @@ def test_query_with_params_passes_correct_args(
         client = Client(flight_url="grpc://localhost:50051", api_key="test-key")
         result = client.query_with_params("SELECT * FROM t WHERE id = $1", [42])
 
-        mock_adbc.query_with_params.assert_called_once_with("SELECT * FROM t WHERE id = $1", [42])
+        mock_adbc.query_with_params.assert_called_once_with(
+            "SELECT * FROM t WHERE id = $1", [42]
+        )
         assert result == mock_reader
 
     @patch("spicepy._client._SpiceFlight")
@@ -781,7 +786,9 @@ def test_spice_flight_query_basic(
         )
 
         # Mock the _threaded_flight_do_get method directly
-        with patch.object(flight_instance, "_threaded_flight_do_get", return_value=mock_reader):
+        with patch.object(
+            flight_instance, "_threaded_flight_do_get", return_value=mock_reader
+        ):
             result = flight_instance.query("SELECT 1")
 
         assert result is mock_reader
@@ -814,7 +821,9 @@ def test_spice_flight_query_with_timeout(
         )
 
         # Mock the _threaded_flight_do_get method directly
-        with patch.object(flight_instance, "_threaded_flight_do_get", return_value=mock_reader):
+        with patch.object(
+            flight_instance, "_threaded_flight_do_get", return_value=mock_reader
+        ):
             flight_instance.query("SELECT 1", timeout=60)
 
     @patch("spicepy._client.flight")
@@ -878,7 +887,9 @@ def mock_threaded_do_get(*args, **kwargs):
                 raise FlightUnauthenticatedError("")
             return mock_reader
 
-        with patch.object(flight_instance, "_threaded_flight_do_get", side_effect=mock_threaded_do_get):
+        with patch.object(
+            flight_instance, "_threaded_flight_do_get", side_effect=mock_threaded_do_get
+        ):
             result = flight_instance.query("SELECT 1")
 
         assert result == mock_reader