Integrate ruff format checking

Author: Epse

.github/workflows/ci.yml

@@ -34,4 +34,5 @@ jobs:
       - uses: astral-sh/setup-uv@v6
       - run: uv python install python3.13
       - run: uv run ruff check src/obelisk/
+      - run: uv run ruff format --check src/obelisk/
       - run: uv run pytest

src/obelisk/asynchronous/__init__.py

@@ -5,6 +5,7 @@
 Relevant entrance points are :class:`client.Obelisk`.
 It can be imported from the :mod:`.client` module, or directly from this one.
 """
-__all__= ['Obelisk', 'core']
+
+__all__ = ["Obelisk", "core"]
 from .client import Obelisk
 from . import core

src/obelisk/asynchronous/base.py

@@ -6,8 +6,7 @@
 import httpx
 
 from obelisk.exceptions import AuthenticationError
-from obelisk.strategies.retry import RetryStrategy, \
-    NoRetryStrategy
+from obelisk.strategies.retry import RetryStrategy, NoRetryStrategy
 from obelisk.types import ObeliskKind
 
 
@@ -32,27 +31,33 @@ class BaseClient:
 
     log: logging.Logger
 
-    def __init__(self, client: str, secret: str,
-                 retry_strategy: RetryStrategy = NoRetryStrategy(),
-                 kind: ObeliskKind = ObeliskKind.CLASSIC) -> None:
+    def __init__(
+        self,
+        client: str,
+        secret: str,
+        retry_strategy: RetryStrategy = NoRetryStrategy(),
+        kind: ObeliskKind = ObeliskKind.CLASSIC,
+    ) -> None:
         self._client = client
         self._secret = secret
         self.retry_strategy = retry_strategy
         self.kind = kind
 
-        self.log = logging.getLogger('obelisk')
+        self.log = logging.getLogger("obelisk")
 
     async def _get_token(self):
-        auth_string = str(base64.b64encode(
-            f'{self._client}:{self._secret}'.encode('utf-8')), 'utf-8')
+        auth_string = str(
+            base64.b64encode(f"{self._client}:{self._secret}".encode("utf-8")), "utf-8"
+        )
         headers = {
-            'Authorization': f'Basic {auth_string}',
-            'Content-Type': ('application/json'
-                             if self.kind.use_json_auth else 'application/x-www-form-urlencoded')
-        }
-        payload = {
-            'grant_type': 'client_credentials'
+            "Authorization": f"Basic {auth_string}",
+            "Content-Type": (
+                "application/json"
+                if self.kind.use_json_auth
+                else "application/x-www-form-urlencoded"
+            ),
         }
+        payload = {"grant_type": "client_credentials"}
 
         async with httpx.AsyncClient() as client:
             response = None
@@ -64,7 +69,8 @@ async def _get_token(self):
                         self.kind.token_url,
                         json=payload if self.kind.use_json_auth else None,
                         data=payload if not self.kind.use_json_auth else None,
-                        headers=headers)
+                        headers=headers,
+                    )
 
                     response = request.json()
                 except Exception as e:
@@ -76,30 +82,33 @@ async def _get_token(self):
                 raise last_error
 
             if request.status_code != 200:
-                if 'error' in response:
+                if "error" in response:
                     self.log.warning(f"Could not authenticate, {response['error']}")
                     raise AuthenticationError
 
-            self._token = response['access_token']
-            self._token_expires = (datetime.now()
-                                  + timedelta(seconds=response['expires_in']))
+            self._token = response["access_token"]
+            self._token_expires = datetime.now() + timedelta(
+                seconds=response["expires_in"]
+            )
 
     async def _verify_token(self):
-        if (self._token is None
-                or self._token_expires < (datetime.now() - self.grace_period)):
+        if self._token is None or self._token_expires < (
+            datetime.now() - self.grace_period
+        ):
             retry = self.retry_strategy.make()
             first = True
             while first or await retry.should_retry():
                 first = False
                 try:
                     await self._get_token()
                     return
-                except: # noqa: E722
+                except:  # noqa: E722
                     self.log.info("excepted, Retrying token fetch")
                     continue
 
-    async def http_post(self, url: str, data: Any = None,
-                        params: Optional[dict] = None) -> httpx.Response:
+    async def http_post(
+        self, url: str, data: Any = None, params: Optional[dict] = None
+    ) -> httpx.Response:
         """
         Send an HTTP POST request to Obelisk,
         with proper auth.
@@ -114,8 +123,8 @@ async def http_post(self, url: str, data: Any = None,
         await self._verify_token()
 
         headers = {
-            'Authorization': f'Bearer {self._token}',
-            'Content-Type': 'application/json'
+            "Authorization": f"Bearer {self._token}",
+            "Content-Type": "application/json",
         }
         if params is None:
             params = {}
@@ -128,11 +137,12 @@ async def http_post(self, url: str, data: Any = None,
                     self.log.debug(f"Retrying, last response: {response.status_code}")
 
                 try:
-                    response = await client.post(url,
-                                                 json=data,
-                                                 params={k: v for k, v in params.items() if
-                                                         v is not None},
-                                                 headers=headers)
+                    response = await client.post(
+                        url,
+                        json=data,
+                        params={k: v for k, v in params.items() if v is not None},
+                        headers=headers,
+                    )
 
                     if response.status_code // 100 == 2:
                         return response
@@ -145,7 +155,6 @@ async def http_post(self, url: str, data: Any = None,
                 raise last_error
             return response
 
-
     async def http_get(self, url: str, params: Optional[dict] = None) -> httpx.Response:
         """
         Send an HTTP GET request to Obelisk,
@@ -161,8 +170,8 @@ async def http_get(self, url: str, params: Optional[dict] = None) -> httpx.Respo
         await self._verify_token()
 
         headers = {
-            'Authorization': f'Bearer {self._token}',
-            'Content-Type': 'application/json'
+            "Authorization": f"Bearer {self._token}",
+            "Content-Type": "application/json",
         }
         if params is None:
             params = {}
@@ -175,10 +184,11 @@ async def http_get(self, url: str, params: Optional[dict] = None) -> httpx.Respo
                     self.log.debug(f"Retrying, last response: {response.status_code}")
 
                 try:
-                    response = await client.get(url,
-                                                 params={k: v for k, v in params.items() if
-                                                         v is not None},
-                                                 headers=headers)
+                    response = await client.get(
+                        url,
+                        params={k: v for k, v in params.items() if v is not None},
+                        headers=headers,
+                    )
 
                     if response.status_code // 100 == 2:
                         return response

src/obelisk/asynchronous/client.py

@@ -90,7 +90,8 @@ async def fetch_single_chunk(
             "limitBy": limit_by,
         }
         response = await self.http_post(
-            self.kind.query_url, data={k: v for k, v in payload.items() if v is not None}
+            self.kind.query_url,
+            data={k: v for k, v in payload.items() if v is not None},
         )
         if response.status_code != 200:
             self.log.warning(f"Unexpected status code: {response.status_code}")
@@ -188,7 +189,6 @@ async def query(
 
         return result_set
 
-
     async def query_time_chunked(
         self,
         datasets: List[str],