chore: restructure src code

Author: atstaeff

eventsourcingdb/__init__.py

@@ -1 +1,38 @@
-from .client import Client as EsdbClient
+from .bound import Bound, BoundType
+from .client import Client
+from .container import Container
+from .event import Event, EventCandidate
+from .errors import ClientError, CustomError, InternalError, ServerError, ValidationError
+from .observe_events import (
+    ObserveEventsOptions,
+    ObserveFromLatestEvent,
+    IfEventIsMissingDuringObserve
+)
+from .read_events import ReadEventsOptions, ReadFromLatestEvent, IfEventIsMissingDuringRead, Order
+from .read_event_types import EventType, is_event_type
+from .read_subjects import is_subject
+from .write_events import Precondition, IsSubjectOnEventId, IsSubjectPristine
+
+
+__all__ = [
+    'Bound', 'BoundType',
+
+    'Client',
+
+    'Container',
+
+    'Event', 'EventCandidate',
+
+    'EventType', 'is_event_type',
+
+    'is_subject',
+
+    'ObserveEventsOptions', 'ObserveFromLatestEvent', 'IfEventIsMissingDuringObserve',
+
+    'Precondition', 'IsSubjectOnEventId', 'IsSubjectPristine',
+
+    'ReadEventsOptions', 'ReadFromLatestEvent', 'IfEventIsMissingDuringRead', 'Order',
+
+    'ClientError', 'CustomError', 'InternalError', 'ServerError', 'ValidationError',
+
+]

eventsourcingdb/handlers/bound.py eventsourcingdb/bound.pyeventsourcingdb/handlers/bound.py renamed to eventsourcingdb/bound.py

@@ -6,25 +6,20 @@
 from http import HTTPStatus
 import json
 
-from .handlers.is_heartbeat import is_heartbeat
-from .handlers.is_stream_error import is_stream_error
-from .handlers.parse_raw_message import parse_raw_message
-from .handlers.is_event import is_event
-
-from .errors.custom_error import CustomError
-from .errors.internal_error import InternalError
-from .errors.server_error import ServerError
-from .errors.validation_error import ValidationError
-from .event.event import Event
-from .event.event_candidate import EventCandidate
-from .handlers.observe_events.observe_events_options import ObserveEventsOptions
-from .handlers.read_event_types.event_type import EventType
-from .handlers.read_event_types.is_event_type import is_event_type
-from .handlers.read_subjects.is_subject import is_subject
-from .handlers.read_events import ReadEventsOptions
-from .handlers.write_events import Precondition
-from .http_client.http_client import HttpClient
-from .http_client.response import Response
+from .is_heartbeat import is_heartbeat
+from .is_stream_error import is_stream_error
+from .is_event import is_event
+from .parse_raw_message import parse_raw_message
+from .read_events import ReadEventsOptions
+
+from .errors import CustomError, InternalError, ServerError, ValidationError
+from .event import Event, EventCandidate
+from .observe_events import ObserveEventsOptions
+from .read_event_types import EventType, is_event_type
+from .read_subjects import is_subject
+
+from .write_events import Precondition
+from .http_client import HttpClient, Response
 
 
 T = TypeVar('T')
@@ -226,7 +221,7 @@ async def run_eventql_query(self, query: str) -> AsyncGenerator[Any]:
 
                 if is_stream_error(message):
                     raise ServerError(f'{message['payload']['error']}.')
-                #pylint: disable=R2004
+                # pylint: disable=R2004
                 if message.get('type') == 'row':
                     payload = message['payload']
 

eventsourcingdb/client.py

@@ -128,7 +128,6 @@ def start(self) -> 'Container':
         if self._container is not None:
             return self
 
-        # Fix too-many-try-statements by breaking into separate methods
         self._pull_or_get_image()
         self._cleanup_existing_containers()
         self._create_container()
@@ -138,25 +137,19 @@ def start(self) -> 'Container':
         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:
@@ -202,7 +195,6 @@ def _wait_for_http(self, path: str, timeout: int) -> None:
             if time.time() - start_time >= timeout:
                 break
 
-            # Extract request into a helper method to reduce try statements
             if self._check_endpoint_available(url):
                 return
 

eventsourcingdb/container.py

@@ -0,0 +1,5 @@
+from .client_error import ClientError
+from .custom_error import CustomError
+from .internal_error import InternalError
+from .server_error import ServerError
+from .validation_error import ValidationError

eventsourcingdb/errors/__init__.py

@@ -0,0 +1,2 @@
+from .event import Event
+from .event_candidate import EventCandidate