clean up code

Author: atstaeff

eventsourcingdb/abstract_base_client.py

@@ -0,0 +1,9 @@
+from abc import ABC, abstractmethod
+from .http_client.http_client import HttpClient
+
+
+class AbstractBaseClient(ABC):
+    @property
+    @abstractmethod
+    def http_client(self) -> HttpClient:
+        raise NotImplementedError()

eventsourcingdb/client.py

@@ -2,7 +2,10 @@
 from types import TracebackType
 from typing import Optional, Type, TypeVar, AsyncIterator
 
+from eventsourcingdb.abstract_base_client import AbstractBaseClient
+
 from .client_configuration import ClientConfiguration
+from .event.event import Event
 from .event.event_candidate import EventCandidate
 from .event.event_context import EventContext
 from .handlers.observe_events.observe_events import observe_events
@@ -14,13 +17,12 @@
 from .handlers.ping import ping
 from .handlers.read_events import read_events, ReadEventsOptions
 from .handlers.read_subjects import read_subjects
-from .handlers.store_item import StoreItem
 from .handlers.write_events import Precondition, write_events
 
 
 T = TypeVar('T')
 
-class Client:
+class Client(AbstractBaseClient):
     def __init__(
         self,
         base_url: str,
@@ -29,7 +31,7 @@ def __init__(
         self.__http_client = HttpClient(base_url=base_url, api_token=api_token)
 
     async def __aenter__(self):
-        await self.__http_client.initialize()
+        await self.__http_client.__aenter__()
         return self
 
     async def __aexit__(
@@ -38,29 +40,28 @@ async def __aexit__(
         exc_val: Optional[BaseException],
         exc_tb: Optional[TracebackType]
     ) -> None:
-        await self.__http_client.close()
+        await self.__http_client.__aexit__(exc_tb=exc_tb, exc_val=exc_val, exc_type=exc_type)
 
-    # Keeping these for backward compatibility and explicit resource management
-    """async def initialize(self) -> None:
+    async def initialize(self) -> None:
         await self.__http_client.initialize()
 
     async def close(self) -> None:
-        await self.__http_client.close() # TODO: should we mix object orientation and functional programming?
-    """
-    def http_client(self) -> # TODO: should we mix object orientation and functional programming?tpClient:
+        await self.__http_client.close() 
+        
+    @property
+    def http_client(self) -> HttpClient:
         return self.__http_client
 
-    # TODO: should we mix object orientation and functional programming?
     async def ping(self) -> None:
-        return await ping(client=self)
+        return await ping(self)
 
     async def verify_api_token(self) -> None:
-        ...
+        raise NotImplementedError("verify_api_token is not implemented yet.")
 
     async def write_events(
         self,
         event_candidates: list[EventCandidate],
-        preconditions: list[Precondition] = None
+        preconditions: list[Precondition] = None # type: ignore
     ) -> list[EventContext]: # TODO: list[Event] of Events (complete)
         if preconditions is None:
             preconditions = []
@@ -70,30 +71,7 @@ async def read_events(
         self,
         subject: str,
         options: ReadEventsOptions
-    ) -> AsyncGenerator[StoreItem, None]: # no StoreItem ... it is a Event
-        #TODO: This is a code snippet for abort read events.
-        """
-        https://github.com/thenativeweb/eventsourcingdb-client-javascript/blob/main/src/Client.ts#L134-L152
-        for await (const event of client.readEvents('/', { recursive: true })) {
-            console.log(event);
-            
-            if (event.ID === '100') {
-                break;
-            }
-        }
-
-
-        function handlePostRequest(abortController) {
-            const signal = abortController.signal;
-
-            for await (const event of client.readEvents('/', { recursive: true }), signal) {
-                console.log(event);
-            }
-            
-            return http.status(200);
-        }
-"""
-        """Read events with proper cancellation support."""
+    ) -> AsyncGenerator[Event, None]: 
         generator = read_events(self, subject, options)
         try:
             async for item in generator:
@@ -105,20 +83,13 @@ async def run_eventql_query(self, query: str) -> AsyncGenerator[Event, None]:
         """
         the issue like read_events. can be abort or canceled.
         """
+        raise NotImplementedError("run_eventql_query is not implemented yet.")
 
     async def observe_events(
         self,
         subject: str,
         options: ObserveEventsOptions
-    ) -> AsyncGenerator[StoreItem, None]: # no StoreItem ... it is a Event
-        """
-        TODO: the same issue like read_events. contextmanager
-        """
-    async def observe_events(
-        self,
-        subject: str,
-        options: ObserveEventsOptions
-    ) -> AsyncGenerator[StoreItem, None]:
+    ) -> AsyncGenerator[Event, None]:
         generator = observe_events(self, subject, options)
         try:
             async for item in generator:
@@ -149,32 +120,4 @@ async def read_event_types(self) -> AsyncGenerator[EventType, None]:
             async for item in generator:
                 yield item
         finally:
-            await generator.aclose()
-
-
-
-""" TODO: 
-
-f (response.status !== 200) {
-					throw new Error(
-						`Failed to read event types, got HTTP status code '${response.status}', expected '200'.`,
-					);
-				}
-
-"""
-
-"""
-
-A: Ausdüngen und Exception
-
-B: Contextmanager
-
-C: Neue Methoden
-
-D: Testcontainer: testcontainers.com Python "virtuelle Container für tests"
-- EventSourcingDB(DockerContainer):
-   def __init__(self):
-    https://github.com/thenativeweb/eventsourcingdb-client-javascript/blob/main/src/EventSourcingDbContainer.ts
-"""
-
-Dokumentationslink für Featurecheck: https://docs.eventsourcingdb.io/client-sdks/compliance-criteria/#detailed-requirements
+            await generator.aclose()

eventsourcingdb/event/event.py

@@ -6,12 +6,6 @@
 
 Self = TypeVar("Self", bound="Event")
 
-# pylint: disable=R0917
-# Reason: This class is expected to have many parameters
-# due to its business context. Splitting it into smaller
-# methods would increase cognitive load and make the
-# code less readable.
-
 
 class Event(EventContext):
     def __init__(
@@ -25,8 +19,8 @@ def __init__(
         time: datetime,
         data_content_type: str,
         predecessor_hash: str,
-        trace_parent: str = None,
-        trace_state: str = None
+        trace_parent: str | None = None,
+        trace_state: str | None  = None
     ):
         super().__init__(
             source,
@@ -43,7 +37,7 @@ def __init__(
         self.data = data
 
     @staticmethod
-    def parse(unknown_object: dict) -> Self:
+    def parse(unknown_object: dict) -> "Event":
         event_context = super(Event, Event).parse(unknown_object)
 
         data = unknown_object.get('data')
@@ -70,4 +64,4 @@ def to_json(self):
         json = super().to_json()
         json['data'] = self.data
 
-        return json
+        return json

eventsourcingdb/event/event_context.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from datetime import datetime
-from typing import TypeVar
+from typing import Any, TypeVar
 
 from ..errors.internal_error import InternalError
 from ..errors.validation_error import ValidationError
@@ -20,11 +20,11 @@ class EventContext:
     time: datetime
     data_content_type: str
     predecessor_hash: str
-    trace_parent: str = None
-    trace_state: str = None
+    trace_parent: str | None  = None
+    trace_state: str | None  = None
 
     @staticmethod
-    def parse(unknown_object: dict) -> Self:
+    def parse(unknown_object: dict) -> "EventContext":
         source = unknown_object.get('source')
         if not isinstance(source, str):
             raise ValidationError(
@@ -100,7 +100,7 @@ def parse(unknown_object: dict) -> Self:
             trace_state=trace_state,
         )
 
-    def to_json(self):
+    def to_json(self) -> dict[Any, Any]:
         json = {
             'specversion': self.spec_version,
             'id': self.event_id,

eventsourcingdb/handlers/bound.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class BoundType(Enum):
+    INCLUSIVE = "inclusive"
+    EXCLUSIVE = "exclusive"
+
+
+@dataclass
+class Bound:
+    id: str
+    type: BoundType

eventsourcingdb/handlers/lower_bound.py

@@ -2,34 +2,28 @@
 from collections.abc import AsyncGenerator
 from http import HTTPStatus
 
+from eventsourcingdb.abstract_base_client import AbstractBaseClient
+
 from ..is_heartbeat import is_heartbeat
 from ..is_event import is_event
 from ..is_stream_error import is_stream_error
 from ..parse_raw_message import parse_raw_message
-from ...client import Client
 from ...errors.custom_error import CustomError
 from ...errors.internal_error import InternalError
 from ...errors.invalid_parameter_error import InvalidParameterError
 from ...errors.server_error import ServerError
 from ...errors.validation_error import ValidationError
 from ...event.event import Event
 from ...event.validate_subject import validate_subject
-from ..store_item import StoreItem
 from .observe_events_options import ObserveEventsOptions
 from ...http_client.response import Response
 
-# pylint: disable=R6007
-# Reason: This method explicitly specifies the return type as None
-# for better readability. Even though it is not necessary,
-# it makes the return type clear without needing to read any
-# documentation or code.
-
 
 async def observe_events(
-    client: Client,
+    client: AbstractBaseClient,
     subject: str,
     options: ObserveEventsOptions
-) -> AsyncGenerator[StoreItem, None]:
+) -> AsyncGenerator[Event, None]:
     try:
         validate_subject(subject)
     except ValidationError as validation_error:
@@ -94,7 +88,7 @@ async def observe_events(
                     ):
                         continue
 
-                yield StoreItem(event, message['payload']['hash'])
+                yield event
                 continue
 
             raise ServerError(

eventsourcingdb/handlers/observe_events/observe_events.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 
-from ..lower_bound import LowerBound
+from ..bound import Bound
 from ...errors.validation_error import ValidationError
 from ...event.validate_subject import validate_subject
 from ...event.validate_type import validate_type
@@ -10,13 +10,13 @@
 @dataclass
 class ObserveEventsOptions:
     recursive: bool
-    lower_bound: LowerBound | None = None
+    lower_bound: Bound | None = None
     from_latest_event: ObserveFromLatestEvent | None = None
 
     def validate(self) -> None:
-        if self.lower_bound is not None and not isinstance(self.lower_bound, LowerBound):
+        if self.lower_bound is not None and not isinstance(self.lower_bound, Bound):
             raise ValidationError(
-                'ObserveEventsOptions are invalid: lower_bound must be a LowerBound object.'
+                'ObserveEventsOptions are invalid: lower_bound must be a Bound object.'
             )
 
         if self.from_latest_event is not None:
@@ -43,18 +43,18 @@ def validate(self) -> None:
                 ) from validation_error
 
     def to_json(self):
-        json = {
+        result = {
             'recursive': self.recursive
         }
 
         # Directly use the object
         if self.lower_bound is not None:
-            json['lowerBound'] = {
+            result['lowerBound'] = {
                 'id': str(self.lower_bound.id),  # Ensure ID is a string
                 'type': self.lower_bound.type
             }
 
         if self.from_latest_event is not None:
-            json['fromLatestEvent'] = self.from_latest_event.to_json()
+            result['fromLatestEvent'] = self.from_latest_event.to_json()
 
-        return json
+        return result

eventsourcingdb/handlers/observe_events/observe_events_options.py

@@ -1,6 +1,7 @@
 from http import HTTPStatus
 import json
-from ..client import Client
+
+from ..abstract_base_client import AbstractBaseClient
 from ..errors.server_error import ServerError
 
 # Define constants for response values
@@ -13,7 +14,7 @@
 PING_RECEIVED_TYPE = "io.eventsourcingdb.api.ping-received"
 
 
-async def ping(client: Client) -> None:
+async def ping(client: AbstractBaseClient) -> None:
     response = await client.http_client.get("/api/v1/ping")
     response_body = bytes.decode(await response.body.read(), encoding="utf-8")