modify linting in http_client

Author: atstaeff

eventsourcingdb/client.py

@@ -41,7 +41,7 @@ async def __aexit__(
         exc_val: BaseException | None = None,
         exc_tb: TracebackType | None = None,
     ) -> None:
-        await self.__http_client.__aexit__(exc_tb=exc_tb, exc_val=exc_val, exc_type=exc_type)
+        await self.__http_client.__aexit__(exc_type, exc_val, exc_tb)
 
     async def initialize(self) -> None:
         await self.__http_client.initialize()

eventsourcingdb/http_client/execute_request.py

@@ -0,0 +1,22 @@
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+import aiohttp
+
+from ..errors.custom_error import CustomError
+from ..errors.internal_error import InternalError
+from ..errors.server_error import ServerError
+from .response import Response
+
+
+async def execute_request(
+    func: Callable[[], Coroutine[Any, Any, Response]]
+) -> Response:
+    try:
+        return await func()
+    except CustomError as custom_error:
+        raise custom_error
+    except aiohttp.ClientError as request_error:
+        raise ServerError(str(request_error)) from request_error
+    except Exception as other_error:
+        raise InternalError(str(other_error)) from other_error

eventsourcingdb/http_client/get_error_message.py

@@ -0,0 +1,22 @@
+import aiohttp
+
+from .response import Response
+
+async def get_error_message(response: Response) -> str:
+    """Extrahiert Fehlermeldung aus der Response."""
+    error_message = f'Request failed with status code \'{response.status_code}\''
+
+    try:
+        encoded_error_reason = await response.body.read()
+    except (aiohttp.ClientError, IOError):  # Use specific exception types instead of Exception
+        pass
+    else:
+        try:
+            error_reason = encoded_error_reason.decode('utf-8')
+        except UnicodeDecodeError:  # Use specific exception type instead of Exception
+            pass
+        else:
+            error_message += f" {error_reason}"
+
+    error_message += '.'
+    return error_message

eventsourcingdb/http_client/get_get_headers.py

@@ -0,0 +1,5 @@
+def get_get_headers(api_token: str, with_authorization: bool) -> dict[str, str]:
+    headers = {}
+    if with_authorization:
+        headers['Authorization'] = f'Bearer {api_token}'
+    return headers

eventsourcingdb/http_client/get_post_headers.py

@@ -0,0 +1,5 @@
+def get_post_headers(api_token: str) -> dict[str, str]:
+    return {
+        'Authorization': f'Bearer {api_token}',
+        'Content-Type': 'application/json'
+    }

eventsourcingdb/http_client/http_client.py

@@ -1,23 +1,16 @@
-from collections import namedtuple
-from collections.abc import Callable, Coroutine
 from types import TracebackType
-from typing import Any, Optional, Type
 
 import aiohttp
 from aiohttp import ClientSession
 
-from .response import Response
-from ..errors.client_error import ClientError
 from ..errors.custom_error import CustomError
-from ..errors.internal_error import InternalError
-from ..errors.server_error import ServerError
 from ..util import url
 
-Range = namedtuple('Range', 'lower, upper')
-
-
-class UninitializedError(CustomError):
-    pass
+from .execute_request import execute_request
+from .get_get_headers import get_get_headers
+from .get_post_headers import get_post_headers
+from .response import Response
+from .validate_response import validate_response
 
 
 class HttpClient:
@@ -36,9 +29,9 @@ async def __aenter__(self):
 
     async def __aexit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType]
+        exc_type: BaseException | None = None,
+        exc_val: BaseException | None = None,
+        exc_tb: TracebackType | None = None,
     ) -> None:
         await self.close()
 
@@ -53,114 +46,67 @@ async def close(self):
             self.__session = None
         return None
 
-    async def __execute_request(
-        self,
-        execute_request: Callable[[], Coroutine[Any, Any, Response]]
-    ) -> Response:
-        try:
-            result = await execute_request()
-            return result
-        except CustomError as custom_error:
-            raise custom_error
-        except aiohttp.ClientError as request_error:
-            raise ServerError(str(request_error)) from request_error
-        except Exception as other_error:
-            raise InternalError(str(other_error)) from other_error
-
-    @staticmethod
-    async def __get_error_message(response: Response):
-        error_message = f'Request failed with status code \'{response.status_code}\''
-
-        # We want to purposefully ignore all errors here, as we're already error handling,
-        # and this function just tries to get more information on a best-effort basis.
-        try:
-            encoded_error_reason = await response.body.read()
-            error_reason = encoded_error_reason.decode('utf-8')
-            error_message += f" {error_reason}"
-        finally:
-            pass
-
-        error_message += '.'
-
-        return error_message
-
-    async def __validate_response(
-        self,
-        response: Response
-    ) -> Response:
-        server_failure_range = Range(500, 600)
-        if server_failure_range.lower <= response.status_code < server_failure_range.upper:
-            raise ServerError(await self.__get_error_message(response))
-
-        client_failure_range = Range(400, 500)
-        if client_failure_range.lower <= response.status_code < client_failure_range.upper:
-            raise ClientError(await self.__get_error_message(response))
-
-        return response
-
-    def __get_post_request_headers(self) -> dict[str, str]:
-        headers = {
-            'Authorization': f'Bearer {self.__api_token}',
-            'Content-Type': 'application/json'
-        }
-
-        return headers
-
     async def post(self, path: str, request_body: str) -> Response:
         if self.__session is None:
-            raise UninitializedError()
+            raise CustomError()
 
-        async def execute_request() -> Response:
+        async def request_executor() -> Response:
+            # Vorbereitung
+            url_path = url.join_segments(self.__base_url, path)
+            headers = get_post_headers(self.__api_token)
+
+            # Request ausführen
             async_response = await self.__session.post(  # type: ignore
-                url.join_segments(
-                    self.__base_url,
-                    path
-                ),
+                url_path,
                 data=request_body,
-                headers=self.__get_post_request_headers(),
+                headers=headers,
             )
 
+            # Response erstellen
             response = Response(async_response)
+
+            # Split try block to have only one statement
+            validated_response = None
             try:
-                result = await self.__validate_response(response)
-                return result
+                validated_response = await validate_response(response)
             except Exception as error:
                 response.close()
                 raise error
 
-        return await self.__execute_request(execute_request)
+            return validated_response
 
-    def __get_get_request_headers(self, with_authorization: bool) -> dict[str, str]:
-        headers = {}
-
-        if with_authorization:
-            headers['Authorization'] = f'Bearer {self.__api_token}'
-
-        return headers
+        return await execute_request(request_executor)
 
     async def get(
         self,
         path: str,
         with_authorization: bool = True,
     ) -> Response:
         if self.__session is None:
-            raise UninitializedError()
+            raise CustomError()
+
+        async def request_executor() -> Response:
+            # Vorbereitung
+            url_path = url.join_segments(self.__base_url, path)
+            headers = get_get_headers(self.__api_token, with_authorization)
 
-        async def execute_request() -> Response:
+            # Request ausführen
             async_response = await self.__session.get(  # type: ignore
-                url.join_segments(
-                    self.__base_url,
-                    path
-                ),
-                headers=self.__get_get_request_headers(with_authorization),
+                url_path,
+                headers=headers,
             )
 
+            # Response erstellen
             response = Response(async_response)
+
+            # Split try block to have only one statement
+            validated_response = None
             try:
-                result = await self.__validate_response(response)
-                return result
+                validated_response = await validate_response(response)
             except Exception as error:
                 response.close()
                 raise error
 
-        return await self.__execute_request(execute_request)
+            return validated_response
+
+        return await execute_request(request_executor)

eventsourcingdb/http_client/validate_response.py

@@ -0,0 +1,19 @@
+from collections import namedtuple
+
+from ..errors.client_error import ClientError
+from ..errors.server_error import ServerError
+from .get_error_message import get_error_message
+from .response import Response
+
+Range = namedtuple('Range', 'lower, upper')
+
+async def validate_response(response: Response) -> Response:
+    server_failure_range = Range(500, 600)
+    if server_failure_range.lower <= response.status_code < server_failure_range.upper:
+        raise ServerError(await get_error_message(response))
+
+    client_failure_range = Range(400, 500)
+    if client_failure_range.lower <= response.status_code < client_failure_range.upper:
+        raise ClientError(await get_error_message(response))
+
+    return response

eventsourcingdb/json_encoder.py

@@ -8,7 +8,7 @@
 class EventSourcingDBJSONEncoder(json.JSONEncoder):
     def default(self, o: Any) -> Any:
         if isinstance(o, Bound):
-            return o.to_dict()
-        elif isinstance(o, Enum):
+            return o.to_json()
+        if isinstance(o, Enum):
             return o.value
         return super().default(o)