fix linting in test

Author: atstaeff

eventsourcingdb/event/event.py

@@ -7,6 +7,7 @@
 Self = TypeVar("Self", bound="Event")
 
 
+# pylint: disable=too-many-arguments, too-many-positional-arguments
 class Event(EventContext):
     def __init__(
         self,

eventsourcingdb/event/event_candidate.py

@@ -1,8 +1,5 @@
 from dataclasses import dataclass
 
-from .validate_subject import validate_subject
-from .validate_type import validate_type
-
 
 @dataclass
 class EventCandidate:
@@ -13,10 +10,6 @@ class EventCandidate:
     trace_parent: str | None = None
     trace_state: str | None = None
 
-    """def validate(self) -> None:
-        validate_subject(self.subject)
-        validate_type(self.type)"""
-
     def to_json(self):
         json = {
             'data': self.data,

eventsourcingdb/event/event_context.py

@@ -4,7 +4,6 @@
 
 from ..errors.internal_error import InternalError
 from ..errors.validation_error import ValidationError
-from .validate_subject import validate_subject
 from .validate_type import validate_type
 
 Self = TypeVar("Self", bound="EventContext")
@@ -34,7 +33,6 @@ def parse(unknown_object: dict) -> "EventContext":
         if not isinstance(subject, str):
             raise ValidationError(
                 f'Failed to parse subject \'{subject}\' to string.')
-        validate_subject(subject)
 
         event_type = unknown_object.get('type')
         if not isinstance(event_type, str):

eventsourcingdb/event/validate_subject.py

@@ -20,7 +20,7 @@ async def observe_events(
     client: AbstractBaseClient,
     subject: str,
     options: ObserveEventsOptions
-) -> AsyncGenerator[Event, None]:
+) -> AsyncGenerator[Event]:
     request_body = json.dumps({
         'subject': subject,
         'options': options.to_json()
@@ -54,17 +54,14 @@ async def observe_events(
 
             if is_event(message):
                 event = Event.parse(message['payload'])
-                # Add client-side filtering by event ID
                 event_id = int(message['payload']['id'])
 
                 if options.lower_bound is not None:
-                    # For inclusive, include events with ID >= lower bound
                     if (
                         options.lower_bound.type == 'inclusive' and  # pylint: disable=R2004
                         int(event_id) < int(options.lower_bound.id)
                     ):
                         continue
-                    # For exclusive, include events with ID > lower bound
                     if (
                         options.lower_bound.type == 'exclusive' and  # pylint: disable=R2004
                         int(event_id) <= int(options.lower_bound.id)

eventsourcingdb/handlers/observe_events/observe_events.py

@@ -3,7 +3,6 @@
 
 from ..bound import Bound
 from ...errors.validation_error import ValidationError
-from ...event.validate_subject import validate_subject
 from ...event.validate_type import validate_type
 from .observe_from_latest_event import ObserveFromLatestEvent
 
@@ -27,14 +26,6 @@ def validate(self) -> None:
                     'lowerBoundId and fromLatestEvent are mutually exclusive'
                 )
 
-            try:
-                validate_subject(self.from_latest_event.subject)
-            except ValidationError as validation_error:
-                raise ValidationError(
-                    f'ReadEventsOptions are invalid: '
-                    f'Failed to validate \'from_latest_event\': {str(validation_error)}'
-                ) from validation_error
-
             try:
                 validate_type(self.from_latest_event.type)
             except ValidationError as validation_error:

eventsourcingdb/handlers/observe_events/observe_events_options.py

@@ -1,16 +1,12 @@
-from collections.abc import Generator
 import json
 from http import HTTPStatus
-from typing import AsyncGenerator
+from collections.abc import AsyncGenerator
 
 from ...abstract_base_client import AbstractBaseClient
 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 ...http_client.response import Response
 from ..is_event import is_event
 from ..is_stream_error import is_stream_error
@@ -22,15 +18,7 @@ async def read_events(
     client: AbstractBaseClient,
     subject: str,
     options: ReadEventsOptions
-) -> AsyncGenerator[Event, None]:
-    """try:
-        validate_subject(subject)
-    except ValidationError as validation_error:
-        raise InvalidParameterError('subject', str(validation_error)) from validation_error
-    except Exception as other_error:
-        raise InternalError(str(other_error)) from other_error
-    """
-
+) -> AsyncGenerator[Event]:
     request_body = json.dumps({
         'subject': subject,
         'options': options.to_json()
@@ -61,31 +49,26 @@ async def read_events(
 
             if is_event(message):
                 event = Event.parse(message['payload'])
-
-                event_id = int(message['payload']['id'])  # Access ID from raw payload
+                event_id = int(message['payload']['id'])
 
                 if options.lower_bound is not None:
-                    # For inclusive, include events with ID >= lower bound
                     if (
                         options.lower_bound.type == 'inclusive' and  # pylint: disable=R2004
                         int(event_id) < int(options.lower_bound.id)
                     ):
                         continue
-                    # For exclusive, include events with ID > lower bound
                     if (
                         options.lower_bound.type == 'exclusive' and  # pylint: disable=R2004
                         int(event_id) <= int(options.lower_bound.id)
                     ):
                         continue
 
                 if options.upper_bound is not None:
-                    # For inclusive, include events with ID <= upper bound
                     if (
                         options.upper_bound.type == 'inclusive' and  # pylint: disable=R2004
                         int(event_id) > int(options.upper_bound.id)
                     ):
                         continue
-                    # For exclusive, include events with ID < upper bound
                     if (
                         options.upper_bound.type == 'exclusive' and  # pylint: disable=R2004
                         int(event_id) >= int(options.upper_bound.id)

eventsourcingdb/handlers/read_events/read_events.py

@@ -3,8 +3,6 @@
 
 from ..bound import Bound
 from .order import Order
-from ...errors.validation_error import ValidationError
-from ...event.validate_subject import validate_subject
 from .read_from_latest_event import ReadFromLatestEvent
 
 
@@ -24,16 +22,15 @@ def to_json(self) -> dict[str, Any]:
         if self.order is not None:
             json['order'] = self.order.value
 
-        # Directly use the objects
         if self.lower_bound is not None:
             json['lowerBound'] = {
-                'id': str(self.lower_bound.id),  # Ensure ID is a string
+                'id': str(self.lower_bound.id),
                 'type': self.lower_bound.type
             }
 
         if self.upper_bound is not None:
             json['upperBound'] = {
-                'id': str(self.upper_bound.id),  # Ensure ID is a string
+                'id': str(self.upper_bound.id),
                 'type': self.upper_bound.type
             }
 

eventsourcingdb/handlers/read_events/read_events_options.py

@@ -5,14 +5,11 @@
 from ...abstract_base_client import AbstractBaseClient
 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 ...http_client.response import Response
 from ..is_stream_error import is_stream_error
 from ..parse_raw_message import parse_raw_message
 from .is_subject import is_subject
-from ...event.validate_subject import validate_subject
 
 # pylint: disable=R6007
 # Reason: This method explicitly specifies the return type as None
@@ -25,13 +22,6 @@ async def read_subjects(
     client: AbstractBaseClient,
     base_subject: str
 ) -> AsyncGenerator[str, None]:
-    try:
-        validate_subject(base_subject)
-    except ValidationError as validation_error:
-        raise InvalidParameterError('base_subject', str(validation_error)) from validation_error
-    except Exception as other_error:
-        raise InternalError(str(other_error)) from other_error
-
     request_body = json.dumps({
         'baseSubject': base_subject
     })

eventsourcingdb/handlers/read_subjects/read_subjects.py

@@ -24,20 +24,12 @@ async def write_events(
             'event_candidates must contain at least one EventCandidate.'
         )
 
-    for event_candidate in event_candidates:
-        """try:
-            event_candidate.validate()
-        except ValidationError as validation_error:
-            raise InvalidParameterError(
-                'event_candidates', str(validation_error)
-            ) from validation_error
-        except Exception as other_error:
-            raise InternalError(str(other_error)) from other_error
-"""
-    request_body = json.dumps({
-        'events': [event_candidate.to_json() for event_candidate in event_candidates],
-        'preconditions': [precondition.to_json() for precondition in preconditions]
-    })
+    request_body = json.dumps(
+        {
+            'events': [event_candidate.to_json() for event_candidate in event_candidates],
+            'preconditions': [precondition.to_json() for precondition in preconditions]
+        }
+    )
 
     response: Response
     try: