fix: linting issues

Author: atstaeff

eventsourcingdb/client.py

@@ -1,5 +1,5 @@
 from collections.abc import AsyncGenerator
-import contextlib
+
 from types import TracebackType
 from typing import Any, TypeVar
 
@@ -84,7 +84,7 @@ async def ping(self) -> None:
 
     async def verify_api_token(self) -> None:
         request_body = json.dumps({})
-        
+
         response: Response = await self.http_client.post(
             path='/api/v1/verify-api-token',
             request_body=request_body,
@@ -99,6 +99,7 @@ async def verify_api_token(self) -> None:
             response_data = bytes.decode(response_data, encoding='utf-8')
             response_json = json.loads(response_data)
 
+            # pylint: disable=R2004
             if not isinstance(response_json, dict) or 'type' not in response_json:
                 raise ServerError('Failed to parse response: {response}')
 
@@ -129,7 +130,7 @@ async def write_events(
 
         if response.status_code != HTTPStatus.OK:
             raise ServerError(
-                f'Unexpected response status:  '
+                f'Unexpected response status: {response}'
             )
 
         response_data = await response.body.read()
@@ -206,7 +207,7 @@ async def read_events(
                     f'{message}.'
                 )
 
-    async def run_eventql_query(self, query: str) -> AsyncGenerator[Any, None]:
+    async def run_eventql_query(self, query: str) -> AsyncGenerator[Any]:
         request_body = json.dumps({
             'query': query,
         })
@@ -224,8 +225,8 @@ async def run_eventql_query(self, query: str) -> AsyncGenerator[Any, None]:
                 message = parse_raw_message(raw_message)
 
                 if is_stream_error(message):
-                    raise ServerError(f'{message["payload"]["error"]}.')
-
+                    raise ServerError(f'{message['payload']['error']}.')
+                #pylint: disable=R2004
                 if message.get('type') == 'row':
                     payload = message['payload']
 

eventsourcingdb/container.py

@@ -128,27 +128,37 @@ def start(self) -> 'Container':
         if self._container is not None:
             return self
 
-        try:
-            # Try to pull the latest image
-            self._docker_client.images.pull(self._image_name, self._image_tag)
-        except errors.APIError as e:
-            # Check if we already have the image locally
-            try:
-                image_name = f"{self._image_name}:{self._image_tag}"
-                self._docker_client.images.get(image_name)
-                # If we get here, the image exists locally, so we can continue
-                logging.warning(f"Warning: Could not pull image: {e}. Using locally cached image.")
-            except errors.ImageNotFound:
-                # If the image isn't available locally either, we can't continue
-                raise RuntimeError(f'Could not pull image and no local image available: {e}') from e
-
+        # Fix too-many-try-statements by breaking into separate methods
+        self._pull_or_get_image()
         self._cleanup_existing_containers()
         self._create_container()
         self._fetch_mapped_port()
         self._wait_for_http('/api/v1/ping', timeout=20)
 
         return self
 
+    def _pull_or_get_image(self) -> None:
+        """Pull the image or use local image if available."""
+        try:
+            # Try to pull the latest image
+            self._docker_client.images.pull(self._image_name, self._image_tag)
+        except errors.APIError as e:
+            # Handle the API error
+            self._handle_image_pull_error(e)
+
+    def _handle_image_pull_error(self, error):
+        """Handle error when pulling image fails by checking for local version."""
+        # Check if we already have the image locally
+        image_name = f"{self._image_name}:{self._image_tag}"
+        try:
+            self._docker_client.images.get(image_name)
+        except errors.ImageNotFound:
+            # If the image isn't available locally either, we can't continue
+            raise RuntimeError(
+                f'Could not pull image and no local image available: {error}') from error
+        # If we get here, the image exists locally, so we can continue
+        logging.warning("Warning: Could not pull image: %s. Using locally cached image.", error)
+
     def stop(self) -> None:
         self._stop_and_remove_container()
 
@@ -159,16 +169,16 @@ def _stop_and_remove_container(self) -> None:
         try:
             self._container.stop()
         except errors.NotFound as e:
-            logging.warning(f'Warning: Container not found while stopping: {e}')
+            logging.warning("Warning: Container not found while stopping: %s", e)
         except errors.APIError as e:
-            logging.warning(f'Warning: API error while stopping container: {e}')
+            logging.warning("Warning: API error while stopping container: %s", e)
 
         try:
             self._container.remove()
         except errors.NotFound as e:
-            logging.warning(f'Warning: Container not found while removing: {e}')
+            logging.warning("Warning: Container not found while removing: %s", e)
         except errors.APIError as e:
-            logging.warning(f'Warning: API error while removing container: {e}')
+            logging.warning("Warning: API error while removing container: %s", e)
 
         self._container = None
         self._mapped_port = None
@@ -192,24 +202,28 @@ def _wait_for_http(self, path: str, timeout: int) -> None:
             if time.time() - start_time >= timeout:
                 break
 
-            response = None
-            status_code = None
-            try:
-                response = requests.get(url, timeout=2)
-            except requests.RequestException:
-                pass
-
-            if response is not None:
-                status_code = response.status_code
-
-            if response is not None and status_code == HTTPStatus.OK:
+            # Extract request into a helper method to reduce try statements
+            if self._check_endpoint_available(url):
                 return
 
             time.sleep(0.5)
 
         self._stop_and_remove_container()
         raise TimeoutError(f'Service failed to become ready within {timeout} seconds')
 
+    def _check_endpoint_available(self, url: str) -> bool:
+        """Check if an HTTP endpoint is available."""
+        try:
+            response = requests.get(url, timeout=2)
+        except requests.RequestException:
+            return False
+        return self._check_response_ok(response)
+
+    # pylint: disable=R6301
+    def _check_response_ok(self, response) -> bool:
+        """Check if the HTTP response indicates success."""
+        return response is not None and response.status_code == HTTPStatus.OK
+
     def with_api_token(self, token: str) -> 'Container':
         self._api_token = token
         return self

eventsourcingdb/http_client/http_client.py

@@ -64,7 +64,8 @@ async def get(
         with_authorization: bool = True,
     ) -> Response:
         if self.__session is None:
-            raise CustomError("HTTP client session not initialized. Call initialize() before making requests.")
+            raise CustomError(
+                "HTTP client session not initialized. Call initialize() before making requests.")
 
         async def __request_executor() -> Response:
             url_path = url.join_segments(self.__base_url, path)

eventsourcingdb/http_client/validate_response.py

@@ -5,6 +5,7 @@
 from eventsourcingdb.errors.server_error import ServerError
 from eventsourcingdb.event.event_candidate import EventCandidate
 from eventsourcingdb.handlers.bound import Bound, BoundType
+# pylint: disable=C0301
 from eventsourcingdb.handlers.observe_events.if_event_is_missing_during_observe import IfEventIsMissingDuringObserve
 from eventsourcingdb.handlers.observe_events.observe_events_options import ObserveEventsOptions
 from eventsourcingdb.handlers.observe_events.observe_from_latest_event import ObserveFromLatestEvent

tests/test_observe_events.py

@@ -1,17 +1,19 @@
-import asyncio
-
 from aiohttp import ClientConnectorDNSError
 import pytest
 
-from eventsourcingdb.errors.server_error import ServerError
 from eventsourcingdb.event.event_candidate import EventCandidate
 
-from .conftest import TestData
 from .shared.database import Database
-from .shared.event.assert_event import assert_event_equals
 
 
 class TestRunEventQLQuery:
+    # Define constants to avoid magic value comparisons
+    EXPECTED_ROW_COUNT = 2
+    FIRST_EVENT_ID = '0'
+    FIRST_EVENT_VALUE = 23
+    SECOND_EVENT_ID = '1'
+    SECOND_EVENT_VALUE = 42
+
     @staticmethod
     @pytest.mark.asyncio
     async def test_throws_error_if_server_is_not_reachable(
@@ -48,7 +50,7 @@ async def test_reads_all_rows_the_query_returns(
             subject='/test',
             type='io.eventsourcingdb.test',
             data={
-                'value': 23,
+                'value': TestRunEventQLQuery.FIRST_EVENT_VALUE,
             },
         )
 
@@ -57,7 +59,7 @@ async def test_reads_all_rows_the_query_returns(
             subject='/test',
             type='io.eventsourcingdb.test',
             data={
-                'value': 42,
+                'value': TestRunEventQLQuery.SECOND_EVENT_VALUE,
             },
         )
 
@@ -67,13 +69,12 @@ async def test_reads_all_rows_the_query_returns(
         async for row in client.run_eventql_query('FROM e IN events PROJECT INTO e'):
             rows_read.append(row)
 
-        assert len(rows_read) == 2
+        assert len(rows_read) == TestRunEventQLQuery.EXPECTED_ROW_COUNT
 
         first_row = rows_read[0]
-        # Use dictionary access instead of attribute access
-        assert first_row['id'] == '0'
-        assert first_row['data']['value'] == 23
+        assert first_row['id'] == TestRunEventQLQuery.FIRST_EVENT_ID
+        assert first_row['data']['value'] == TestRunEventQLQuery.FIRST_EVENT_VALUE
 
         second_row = rows_read[1]
-        assert second_row['id'] == '1'
-        assert second_row['data']['value'] == 42
+        assert second_row['id'] == TestRunEventQLQuery.SECOND_EVENT_ID
+        assert second_row['data']['value'] == TestRunEventQLQuery.SECOND_EVENT_VALUE

tests/test_run_eventql_query.py

@@ -1,7 +1,6 @@
 import pytest
 
 from eventsourcingdb.client import Client
-from eventsourcingdb.errors.custom_error import CustomError
 from eventsourcingdb.errors.server_error import ServerError
 
 from .shared.database import Database
@@ -16,7 +15,6 @@ async def test_does_not_throw_if_token_is_valid(
         client = database.get_client()
         await client.verify_api_token()
 
-
     @staticmethod
     @pytest.mark.asyncio
     async def test_throws_error_if_token_is_invalid(