Fix ld_eventsource

Author: keelerm84

ld_eventsource/actions.py

@@ -17,11 +17,13 @@ class Event(Action):
     Instances of this class are returned by both :attr:`.SSEClient.events` and
     :attr:`.SSEClient.all`.
     """
-    def __init__(self,
-        event: str='message',
-        data: str='',
-        id: Optional[str]=None,
-        last_event_id: Optional[str]=None
+
+    def __init__(
+        self,
+        event: str = 'message',
+        data: str = '',
+        id: Optional[str] = None,
+        last_event_id: Optional[str] = None,
     ):
         self._event = event
         self._data = data
@@ -59,8 +61,12 @@ def last_event_id(self) -> Optional[str]:
     def __eq__(self, other):
         if not isinstance(other, Event):
             return False
-        return self._event == other._event and self._data == other._data \
-            and self._id == other._id and self.last_event_id == other.last_event_id
+        return (
+            self._event == other._event
+            and self._data == other._data
+            and self._id == other._id
+            and self.last_event_id == other.last_event_id
+        )
 
     def __repr__(self):
         return "Event(event=\"%s\", data=%s, id=%s, last_event_id=%s)" % (

ld_eventsource/config/__init__.py

@@ -1,3 +1,4 @@
-from .connect_strategy import ConnectionClient, ConnectionResult, ConnectStrategy
+from .connect_strategy import (ConnectionClient, ConnectionResult,
+                               ConnectStrategy)
 from .error_strategy import ErrorStrategy
 from .retry_delay_strategy import RetryDelayStrategy

ld_eventsource/config/connect_strategy.py

@@ -35,9 +35,9 @@ def create_client(self, logger: Logger) -> ConnectionClient:
     @staticmethod
     def http(
         url: str,
-        headers: Optional[dict]=None,
-        pool: Optional[PoolManager]=None,
-        urllib3_request_options: Optional[dict]=None
+        headers: Optional[dict] = None,
+        pool: Optional[PoolManager] = None,
+        urllib3_request_options: Optional[dict] = None,
     ) -> ConnectStrategy:
         """
         Creates the default HTTP implementation, specifying request parameters.
@@ -48,7 +48,9 @@ def http(
         :param urllib3_request_options: optional ``kwargs`` to add to the ``request`` call; these
             can include any parameters supported by ``urllib3``, such as ``timeout``
         """
-        return _HttpConnectStrategy(_HttpConnectParams(url, headers, pool, urllib3_request_options))
+        return _HttpConnectStrategy(
+            _HttpConnectParams(url, headers, pool, urllib3_request_options)
+        )
 
 
 class ConnectionClient:
@@ -67,7 +69,9 @@ def connect(self, last_event_id: Optional[str]) -> ConnectionResult:
             (should be sent to the server to support resuming an interrupted stream)
         :return: a :class:`ConnectionResult` representing the stream
         """
-        raise NotImplementedError("ConnectionClient base class cannot be used by itself")
+        raise NotImplementedError(
+            "ConnectionClient base class cannot be used by itself"
+        )
 
     def close(self):
         """
@@ -82,16 +86,12 @@ def __exit__(self, type, value, traceback):
         self.close()
 
 
-
 class ConnectionResult:
     """
     The return type of :meth:`ConnectionClient.connect()`.
     """
-    def __init__(
-        self,
-        stream: Iterator[bytes],
-        closer: Optional[Callable]
-    ):
+
+    def __init__(self, stream: Iterator[bytes], closer: Optional[Callable]):
         self.__stream = stream
         self.__closer = closer
 

ld_eventsource/config/error_strategy.py

@@ -86,7 +86,9 @@ def continue_with_time_limit(max_time: float) -> ErrorStrategy:
         return _TimeLimitErrorStrategy(max_time, 0)
 
     @staticmethod
-    def from_lambda(fn: Callable[[Optional[Exception]], Tuple[bool, Optional[ErrorStrategy]]]) -> ErrorStrategy:
+    def from_lambda(
+        fn: Callable[[Optional[Exception]], Tuple[bool, Optional[ErrorStrategy]]]
+    ) -> ErrorStrategy:
         """
         Convenience method for creating an ErrorStrategy whose ``apply`` method is equivalent to
         the given lambda.
@@ -98,7 +100,9 @@ def from_lambda(fn: Callable[[Optional[Exception]], Tuple[bool, Optional[ErrorSt
 
 
 class _LambdaErrorStrategy(ErrorStrategy):
-    def __init__(self, fn: Callable[[Optional[Exception]], Tuple[bool, Optional[ErrorStrategy]]]):
+    def __init__(
+        self, fn: Callable[[Optional[Exception]], Tuple[bool, Optional[ErrorStrategy]]]
+    ):
         self.__fn = fn
 
     def apply(self, exception: Optional[Exception]) -> Tuple[bool, ErrorStrategy]:
@@ -114,7 +118,10 @@ def __init__(self, max_attempts: int, counter: int):
     def apply(self, exception: Optional[Exception]) -> Tuple[bool, ErrorStrategy]:
         if self.__counter >= self.__max_attempts:
             return (ErrorStrategy.FAIL, self)
-        return (ErrorStrategy.CONTINUE, _MaxAttemptsErrorStrategy(self.__max_attempts, self.__counter + 1))
+        return (
+            ErrorStrategy.CONTINUE,
+            _MaxAttemptsErrorStrategy(self.__max_attempts, self.__counter + 1),
+        )
 
 
 class _TimeLimitErrorStrategy(ErrorStrategy):
@@ -124,7 +131,10 @@ def __init__(self, max_time: float, start_time: float):
 
     def apply(self, exception: Optional[Exception]) -> Tuple[bool, ErrorStrategy]:
         if self.__start_time == 0:
-            return (ErrorStrategy.CONTINUE, _TimeLimitErrorStrategy(self.__max_time, time.time()))
+            return (
+                ErrorStrategy.CONTINUE,
+                _TimeLimitErrorStrategy(self.__max_time, time.time()),
+            )
         if (time.time() - self.__start_time) < self.__max_time:
             return (ErrorStrategy.CONTINUE, self)
         return (ErrorStrategy.FAIL, self)

ld_eventsource/config/retry_delay_strategy.py

@@ -34,7 +34,7 @@ def apply(self, base_delay: float) -> Tuple[float, RetryDelayStrategy]:
     def default(
         max_delay: Optional[float] = None,
         backoff_multiplier: float = 2,
-        jitter_multiplier: Optional[float] = None
+        jitter_multiplier: Optional[float] = None,
     ) -> RetryDelayStrategy:
         """
         Provides the default retry delay behavior for :class:`.SSEClient`, which includes
@@ -59,11 +59,18 @@ def default(
         :param jitter_multiplier: a fraction from 0.0 to 1.0 for how much of the delay may be
             pseudo-randomly subtracted
         """
-        return _DefaultRetryDelayStrategy(max_delay or 0, backoff_multiplier, jitter_multiplier or 0,
-            0, _ReusableRandom(time.time()))
+        return _DefaultRetryDelayStrategy(
+            max_delay or 0,
+            backoff_multiplier,
+            jitter_multiplier or 0,
+            0,
+            _ReusableRandom(time.time()),
+        )
 
     @staticmethod
-    def from_lambda(fn: Callable[[float], Tuple[float, Optional[RetryDelayStrategy]]]) -> RetryDelayStrategy:
+    def from_lambda(
+        fn: Callable[[float], Tuple[float, Optional[RetryDelayStrategy]]]
+    ) -> RetryDelayStrategy:
         """
         Convenience method for creating a RetryDelayStrategy whose ``apply`` method is equivalent to
         the given lambda.
@@ -81,7 +88,7 @@ def __init__(
         backoff_multiplier: float,
         jitter_multiplier: float,
         last_base_delay: float,
-        random: _ReusableRandom
+        random: _ReusableRandom,
     ):
         self.__max_delay = max_delay
         self.__backoff_multiplier = backoff_multiplier
@@ -90,8 +97,11 @@ def __init__(
         self.__random = random
 
     def apply(self, base_delay: float) -> Tuple[float, RetryDelayStrategy]:
-        next_base_delay = base_delay if self.__last_base_delay == 0 else \
-            self.__last_base_delay * self.__backoff_multiplier
+        next_base_delay = (
+            base_delay
+            if self.__last_base_delay == 0
+            else self.__last_base_delay * self.__backoff_multiplier
+        )
         if self.__max_delay > 0 and next_base_delay > self.__max_delay:
             next_base_delay = self.__max_delay
         adjusted_delay = next_base_delay
@@ -101,19 +111,24 @@ def apply(self, base_delay: float) -> Tuple[float, RetryDelayStrategy]:
             # To avoid having this object contain mutable state, we create a new Random with the same
             # state as our previous Random before using it.
             random = random.clone()
-            adjusted_delay -= (random.random() * self.__jitter_multiplier * adjusted_delay)
+            adjusted_delay -= (
+                random.random() * self.__jitter_multiplier * adjusted_delay
+            )
 
         next_strategy = _DefaultRetryDelayStrategy(
             self.__max_delay,
             self.__backoff_multiplier,
             self.__jitter_multiplier,
             next_base_delay,
-            random
+            random,
         )
         return (adjusted_delay, next_strategy)
 
+
 class _LambdaRetryDelayStrategy(RetryDelayStrategy):
-    def __init__(self, fn: Callable[[float], Tuple[float, Optional[RetryDelayStrategy]]]):
+    def __init__(
+        self, fn: Callable[[float], Tuple[float, Optional[RetryDelayStrategy]]]
+    ):
         self.__fn = fn
 
     def apply(self, base_delay: float) -> Tuple[float, RetryDelayStrategy]:

ld_eventsource/http.py

@@ -14,9 +14,9 @@ class _HttpConnectParams:
     def __init__(
         self,
         url: str,
-        headers: Optional[dict]=None,
-        pool: Optional[PoolManager]=None,
-        urllib3_request_options: Optional[dict]=None
+        headers: Optional[dict] = None,
+        pool: Optional[PoolManager] = None,
+        urllib3_request_options: Optional[dict] = None,
     ):
         self.__url = url
         self.__headers = headers
@@ -57,24 +57,33 @@ def connect(self, last_event_id: Optional[str]) -> Tuple[Iterator[bytes], Callab
         if last_event_id:
             headers['Last-Event-ID'] = last_event_id
 
-        request_options = self.__params.urllib3_request_options.copy() if self.__params.urllib3_request_options else {}
+        request_options = (
+            self.__params.urllib3_request_options.copy()
+            if self.__params.urllib3_request_options
+            else {}
+        )
         request_options['headers'] = headers
 
         try:
             resp = self.__pool.request(
                 'GET',
                 self.__params.url,
                 preload_content=False,
-                retries=Retry(total=None, read=0, connect=0, status=0, other=0, redirect=3),
-                **request_options)
+                retries=Retry(
+                    total=None, read=0, connect=0, status=0, other=0, redirect=3
+                ),
+                **request_options
+            )
         except MaxRetryError as e:
             reason: Optional[Exception] = e.reason
             if reason is not None:
-                raise reason  # e.reason is the underlying I/O error        
+                raise reason  # e.reason is the underlying I/O error
         if resp.status >= 400 or resp.status == 204:
             raise HTTPStatusError(resp.status)
         content_type = resp.headers.get('Content-Type', None)
-        if content_type is None or not str(content_type).startswith("text/event-stream"):
+        if content_type is None or not str(content_type).startswith(
+            "text/event-stream"
+        ):
             raise HTTPContentTypeError(content_type or '')
 
         stream = resp.stream(_CHUNK_SIZE)

ld_eventsource/reader.py

@@ -56,8 +56,8 @@ def __init__(
         self,
         lines_source: Iterable[str],
         last_event_id: Optional[str] = None,
-        set_retry: Optional[Callable[[int], None]] = None
-        ):
+        set_retry: Optional[Callable[[int], None]] = None,
+    ):
         self._lines_source = lines_source
         self._last_event_id = last_event_id
         self._set_retry = set_retry
@@ -80,7 +80,7 @@ def events_and_comments(self):
                         "message" if event_type == "" else event_type,
                         event_data,
                         event_id,
-                        self._last_event_id
+                        self._last_event_id,
                     )
                 event_type = ""
                 event_data = None
@@ -97,11 +97,13 @@ def events_and_comments(self):
                 name = line[:colon_pos]
                 if colon_pos < (len(line) - 1) and line[colon_pos + 1] == ' ':
                     colon_pos += 1
-                value = line[colon_pos+1:]
+                value = line[colon_pos + 1:]
             if name == 'event':
                 event_type = value
             elif name == 'data':
-                event_data = value if event_data is None else (event_data + "\n" + value)
+                event_data = (
+                    value if event_data is None else (event_data + "\n" + value)
+                )
             elif name == 'id':
                 if value.find("\x00") < 0:
                     event_id = value