use ruff for formatting (#162)

Author: mewwts

.github/workflows/pull-request.yaml

@@ -4,11 +4,11 @@ on:
   push:
     branches: [ main ]
 jobs:
-  lint-format-types-unit:
+  lint-format-types:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.13"]
+        python-version: ["3.13"]
     steps:
       - uses: actions/checkout@v4
       - name: Install uv
@@ -20,29 +20,32 @@ jobs:
         run: uv python install ${{ matrix.python-version }}
       - name: Install dependencies
         run: uv sync --extra dev
-      - name: Pylint
-        run: uv run pylint dune_client/
-      - name: Black
-        run: uv run black --check ./
+      - name: Format Check
+        run: make fmt
+      - name: Lint
+        run: make lint
       - name: Type Check (mypy)
-        run: uv run mypy dune_client --strict
-      - name: Unit Tests
-        run: uv run python -m pytest tests/unit
+        run: make types
 
-  e2e-tests:
+  tests:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.13"]
     steps:
       - uses: actions/checkout@v4
       - name: Install uv
         uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
           cache-dependency-glob: "uv.lock"
-      - name: Set up Python 3.13
-        run: uv python install 3.13
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
       - name: Install dependencies
         run: uv sync --extra dev
+      - name: Unit Tests
+        run: make test-unit
       - name: End to End Tests
         env:
           DUNE_API_KEY: ${{ secrets.DUNE_API_KEY }}
-        run: uv run python -m pytest tests/e2e
+        run: make test-e2e

Makefile

@@ -13,10 +13,13 @@ clean:
 	rm -rf __pycache__
 
 fmt:
-	uv run black ./
+	uv run ruff format
 
 lint:
-	uv run pylint dune_client/
+	uv run ruff check
+
+lint-fix:
+	uv run ruff check --fix
 
 types:
 	uv run mypy dune_client/ --strict

dune_client/api/base.py

@@ -9,7 +9,7 @@
 import logging.config
 import os
 from json import JSONDecodeError
-from typing import Any, Dict, List, Optional, Union, IO
+from typing import IO, Any
 
 from requests import Response, Session
 from requests.adapters import HTTPAdapter, Retry
@@ -23,14 +23,13 @@
 MAX_NUM_ROWS_PER_BATCH = 32_000
 
 
-# pylint: disable=too-few-public-methods
 class BaseDuneClient:
     """
     A Base Client for Dune which sets up default values
     and provides some convenient functions to use in other clients
     """
 
-    def __init__(  # pylint: disable=too-many-arguments
+    def __init__(
         self,
         api_key: str,
         base_url: str = "https://api.dune.com",
@@ -67,15 +66,15 @@ def from_env(cls) -> BaseDuneClient:
         return cls(
             api_key=os.environ["DUNE_API_KEY"],
             base_url=os.environ.get("DUNE_API_BASE_URL", "https://api.dune.com"),
-            request_timeout=float(os.environ.get("DUNE_API_REQUEST_TIMEOUT", 10)),
+            request_timeout=float(os.environ.get("DUNE_API_REQUEST_TIMEOUT", "10")),
         )
 
     @property
     def api_version(self) -> str:
         """Returns client version string"""
         return f"/api/{self.client_version}"
 
-    def default_headers(self) -> Dict[str, str]:
+    def default_headers(self) -> dict[str, str]:
         """Return default headers containing Dune Api token"""
         client_version = get_package_version("dune-client") or "1.3.0"
         return {
@@ -89,15 +88,15 @@ def default_headers(self) -> Dict[str, str]:
 
     def _build_parameters(
         self,
-        params: Optional[Dict[str, Union[str, int]]] = None,
-        columns: Optional[List[str]] = None,
-        sample_count: Optional[int] = None,
-        filters: Optional[str] = None,
-        sort_by: Optional[List[str]] = None,
-        limit: Optional[int] = None,
-        offset: Optional[int] = None,
+        params: dict[str, str | int] | None = None,
+        columns: list[str] | None = None,
+        sample_count: int | None = None,
+        filters: str | None = None,
+        sort_by: list[str] | None = None,
+        limit: int | None = None,
+        offset: int | None = None,
         allow_partial_results: str = "true",
-    ) -> Dict[str, Union[str, int]]:
+    ) -> dict[str, str | int]:
         """
         Utility function that builds a dictionary of parameters to be used
         when retrieving advanced results (filters, pagination, sorting, etc.).
@@ -138,13 +137,14 @@ def _handle_response(self, response: Response) -> Any:
             # Some responses can be decoded and converted to DuneErrors
             response_json = response.json()
             self.logger.debug(f"received response {response_json}")
-            return response_json
         except JSONDecodeError as err:
             # Others can't. Only raise HTTP error for not decodable errors
             response.raise_for_status()
             raise ValueError("Unreachable since previous line raises") from err
+        else:
+            return response_json
 
-    def _route_url(self, route: Optional[str] = None, url: Optional[str] = None) -> str:
+    def _route_url(self, route: str | None = None, url: str | None = None) -> str:
         if route is not None:
             final_url = f"{self.base_url}{self.api_version}{route}"
         elif url is not None:
@@ -156,10 +156,10 @@ def _route_url(self, route: Optional[str] = None, url: Optional[str] = None) ->
 
     def _get(
         self,
-        route: Optional[str] = None,
-        params: Optional[Any] = None,
+        route: str | None = None,
+        params: Any | None = None,
         raw: bool = False,
-        url: Optional[str] = None,
+        url: str | None = None,
     ) -> Any:
         """Generic interface for the GET method of a Dune API request"""
         final_url = self._route_url(route=route, url=url)
@@ -178,9 +178,9 @@ def _get(
     def _post(
         self,
         route: str,
-        params: Optional[Any] = None,
-        data: Optional[IO[bytes]] = None,
-        headers: Optional[Dict[str, str]] = None,
+        params: Any | None = None,
+        data: IO[bytes] | None = None,
+        headers: dict[str, str] | None = None,
     ) -> Any:
         """Generic interface for the POST method of a Dune API request"""
         url = self._route_url(route)

dune_client/api/custom.py

@@ -4,7 +4,6 @@
 """
 
 from __future__ import annotations
-from typing import List, Optional
 
 from dune_client.api.base import BaseRouter
 from dune_client.models import (
@@ -13,7 +12,6 @@
 )
 
 
-# pylint: disable=duplicate-code
 class CustomEndpointAPI(BaseRouter):
     """
     Custom endpoints API implementation.
@@ -25,12 +23,12 @@ def get_custom_endpoint_result(
         self,
         handle: str,
         endpoint: str,
-        limit: Optional[int] = None,
-        offset: Optional[int] = None,
-        columns: Optional[List[str]] = None,
-        sample_count: Optional[int] = None,
-        filters: Optional[str] = None,
-        sort_by: Optional[List[str]] = None,
+        limit: int | None = None,
+        offset: int | None = None,
+        columns: list[str] | None = None,
+        sample_count: int | None = None,
+        filters: str | None = None,
+        sort_by: list[str] | None = None,
     ) -> ResultsResponse:
         """
         Custom endpoints allow you to fetch and filter data from any

dune_client/api/execution.py

@@ -12,17 +12,17 @@
 from deprecated import deprecated
 
 from dune_client.api.base import (
-    BaseRouter,
-    DUNE_CSV_NEXT_URI_HEADER,
     DUNE_CSV_NEXT_OFFSET_HEADER,
+    DUNE_CSV_NEXT_URI_HEADER,
+    BaseRouter,
 )
 from dune_client.models import (
+    DuneError,
     ExecutionResponse,
-    ExecutionStatusResponse,
-    ResultsResponse,
     ExecutionResultCSV,
-    DuneError,
     ExecutionState,
+    ExecutionStatusResponse,
+    ResultsResponse,
 )
 from dune_client.query import QueryBase
 
@@ -39,9 +39,7 @@ def execute_query(
         params = query.request_format()
         params["performance"] = performance or self.performance
 
-        self.logger.info(
-            f"executing {query.query_id} on {performance or self.performance} cluster"
-        )
+        self.logger.info(f"executing {query.query_id} on {performance or self.performance} cluster")
         response_json = self._post(
             route=f"/query/{query.query_id}/execute",
             params=params,
@@ -60,9 +58,10 @@ def cancel_execution(self, job_id: str) -> bool:
         try:
             # No need to make a dataclass for this since it's just a boolean.
             success: bool = response_json["success"]
-            return success
         except KeyError as err:
             raise DuneError(response_json, "CancellationResponse", err) from err
+        else:
+            return success
 
     def get_execution_status(self, job_id: str) -> ExecutionStatusResponse:
         """GET status from Dune API for `job_id` (aka `execution_id`)"""
@@ -144,9 +143,10 @@ def _get_execution_results_by_url(
                     f"execution {result.execution_id} resulted in a partial "
                     f"result set (i.e. results too large)."
                 )
-            return result
         except KeyError as err:
             raise DuneError(response_json, "ResultsResponse", err) from err
+        else:
+            return result
 
     def _get_execution_results_csv_by_url(
         self,
@@ -177,9 +177,7 @@ def _get_execution_results_csv_by_url(
     # Deprecated Functions:
     #######################
     @deprecated(version="1.2.1", reason="Please use execute_query")
-    def execute(
-        self, query: QueryBase, performance: Optional[str] = None
-    ) -> ExecutionResponse:
+    def execute(self, query: QueryBase, performance: Optional[str] = None) -> ExecutionResponse:
         """Post's to Dune API for execute `query`"""
         return self.execute_query(query, performance)