Trimming some whitespace

Author: keelerm84

contract-tests/service.py

@@ -54,11 +54,13 @@ def status():
     }
     return (json.dumps(body), 200, {'Content-type': 'application/json'})
 
+
 @app.route('/', methods=['DELETE'])
 def delete_stop_service():
     global_log.info("Test service has told us to exit")
     os._exit(0)
 
+
 @app.route('/', methods=['POST'])
 def post_create_stream():
     global stream_counter, streams
@@ -74,6 +76,7 @@ def post_create_stream():
 
     return ('', 201, {'Location': resource_url})
 
+
 @app.route('/streams/<id>', methods=['POST'])
 def post_stream_command(id):
     global streams
@@ -87,6 +90,7 @@ def post_stream_command(id):
         return ('', 400)
     return ('', 204)
 
+
 @app.route('/streams/<id>', methods=['DELETE'])
 def delete_stream(id):
     global streams
@@ -97,6 +101,7 @@ def delete_stream(id):
     stream.close()
     return ('', 204)
 
+
 if __name__ == "__main__":
     port = default_port
     if sys.argv[len(sys.argv) - 1] != 'service.py':

contract-tests/stream_entity.py

@@ -15,6 +15,7 @@
 
 http_client = urllib3.PoolManager()
 
+
 def millis_to_seconds(t):
     return None if t is None else t / 1000
 
@@ -27,7 +28,7 @@ def __init__(self, options):
         self.closed = False
         self.callback_counter = 0
         self.sse = None
-        
+
         thread = threading.Thread(target=self.run)
         thread.start()
 
@@ -91,7 +92,7 @@ def do_command(self, command: str) -> bool:
         self.log.info('Test service sent command: %s' % command)
         # currently we support no special commands
         return False
-    
+
     def send_message(self, message):
         global http_client
 

ld_eventsource/actions.py

@@ -6,6 +6,7 @@ class Action:
     """
     Base class for objects that can be returned by :attr:`.SSEClient.all`.
     """
+
     pass
 
 
@@ -66,19 +67,19 @@ def __repr__(self):
             self._event,
             json.dumps(self._data),
             "None" if self._id is None else json.dumps(self._id),
-            "None" if self._last_event_id is None else json.dumps(self._last_event_id)
+            "None" if self._last_event_id is None else json.dumps(self._last_event_id),
         )
 
 
 class Comment(Action):
     """
     A comment received by :class:`.SSEClient`.
-    
+
     Comment lines (any line beginning with a colon) have no significance in the SSE specification
     and can be ignored, but if you want to see them, use :attr:`.SSEClient.all`. They will never
     be returned by :attr:`.SSEClient.events`.
     """
-    
+
     def __init__(self, comment: str):
         self._comment = comment
 
@@ -104,6 +105,7 @@ class Start(Action):
     A ``Start`` is returned for the first successful connection. If the client reconnects
     after a failure, there will be a :class:`.Fault` followed by a ``Start``.
     """
+
     pass
 
 
@@ -121,7 +123,7 @@ class Fault(Action):
 
     def __init__(self, error: Optional[Exception]):
         self.__error = error
-    
+
     @property
     def error(self) -> Optional[Exception]:
         """

ld_eventsource/config/__init__.py

@@ -1,4 +1,3 @@
-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

@@ -120,6 +120,7 @@ def __exit__(self, type, value, traceback):
 # _HttpConnectStrategy and _HttpConnectionClient are defined here rather than in http.py to avoid
 # a circular module reference.
 
+
 class _HttpConnectStrategy(ConnectStrategy):
     def __init__(self, params: _HttpConnectParams):
         self.__params = params

ld_eventsource/config/error_strategy.py

@@ -8,7 +8,7 @@ class ErrorStrategy:
     """
     Base class of strategies for determining how SSEClient should handle a stream error or the
     end of a stream.
-    
+
     The parameter that SSEClient passes to :meth:`apply()` is either ``None`` if the server ended
     the stream normally, or an exception. If it is an exception, it could be an I/O exception
     (failure to connect, broken connection, etc.), or one of the error types defined in this
@@ -25,7 +25,7 @@ class ErrorStrategy:
     With either option, it is still always possible to explicitly reconnect the stream by calling
     :meth:`.SSEClient.start()` again, or simply by trying to read from :attr:`.SSEClient.events`
     or :attr:`.SSEClient.all` again.
-    
+
     Subclasses should be immutable. To implement strategies that behave differently on consecutive
     retries, the strategy should return a new instance of its own class as the second return value
     from ``apply``, rather than modifying the state of the existing instance. This makes it easy
@@ -74,7 +74,7 @@ def continue_with_max_attempts(max_attempts: int) -> ErrorStrategy:
         :param max_attempts: the maximum number of consecutive retries
         """
         return _MaxAttemptsErrorStrategy(max_attempts, 0)
-    
+
     @staticmethod
     def continue_with_time_limit(max_time: float) -> ErrorStrategy:
         """
@@ -90,7 +90,7 @@ def from_lambda(fn: Callable[[Optional[Exception]], Tuple[bool, Optional[ErrorSt
         """
         Convenience method for creating an ErrorStrategy whose ``apply`` method is equivalent to
         the given lambda.
-        
+
         The one difference is that the second return value is an ``Optional[ErrorStrategy]`` which
         can be None to mean "no change", since the lambda cannot reference the strategy's ``self``.
         """
@@ -100,26 +100,28 @@ 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]]]):
         self.__fn = fn
-    
+
     def apply(self, exception: Optional[Exception]) -> Tuple[bool, ErrorStrategy]:
         should_raise, maybe_next = self.__fn(exception)
         return (should_raise, maybe_next or self)
 
+
 class _MaxAttemptsErrorStrategy(ErrorStrategy):
     def __init__(self, max_attempts: int, counter: int):
         self.__max_attempts = max_attempts
         self.__counter = counter
-    
+
     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))
 
+
 class _TimeLimitErrorStrategy(ErrorStrategy):
     def __init__(self, max_time: float, start_time: float):
         self.__max_time = max_time
         self.__start_time = start_time
-    
+
     def apply(self, exception: Optional[Exception]) -> Tuple[bool, ErrorStrategy]:
         if self.__start_time == 0:
             return (ErrorStrategy.CONTINUE, _TimeLimitErrorStrategy(self.__max_time, time.time()))

ld_eventsource/config/retry_delay_strategy.py

@@ -120,6 +120,7 @@ def apply(self, base_delay: float) -> Tuple[float, RetryDelayStrategy]:
         delay, maybe_next = self.__fn(base_delay)
         return (delay, maybe_next or self)
 
+
 class _ReusableRandom:
     def __init__(self, seed: float):
         self.__seed = seed

ld_eventsource/errors.py

@@ -1,4 +1,3 @@
-
 class HTTPStatusError(Exception):
     """
     This exception indicates that the client was able to connect to the server, but that
@@ -8,11 +7,12 @@ class HTTPStatusError(Exception):
     def __init__(self, status: int):
         super().__init__("HTTP error %d" % status)
         self._status = status
-    
+
     @property
     def status(self) -> int:
         return self._status
 
+
 class HTTPContentTypeError(Exception):
     """
     This exception indicates that the HTTP response did not have the expected content
@@ -22,7 +22,7 @@ class HTTPContentTypeError(Exception):
     def __init__(self, content_type: str):
         super().__init__("invalid content type \"%s\"" % content_type)
         self._content_type = content_type
-    
+
     @property
     def content_type(self) -> str:
         return self._content_type

ld_eventsource/http.py

@@ -26,15 +26,15 @@ def __init__(
     @property
     def url(self) -> str:
         return self.__url
-    
+
     @property
     def headers(self) -> Optional[dict]:
         return self.__headers
-    
+
     @property
     def pool(self) -> Optional[PoolManager]:
         return self.__pool
-    
+
     @property
     def urllib3_request_options(self) -> Optional[dict]:
         return self.__urllib3_request_options
@@ -46,10 +46,10 @@ def __init__(self, params: _HttpConnectParams, logger: Logger):
         self.__pool = params.pool or PoolManager()
         self.__should_close_pool = params.pool is not None
         self.__logger = logger
-    
+
     def connect(self, last_event_id: Optional[str]) -> Tuple[Iterator[bytes], Callable]:
         self.__logger.info("Connecting to stream at %s" % self.__params.url)
-        
+
         headers = self.__params.headers.copy() if self.__params.headers else {}
         headers['Cache-Control'] = 'no-cache'
         headers['Accept'] = 'text/event-stream'

ld_eventsource/reader.py

@@ -8,6 +8,7 @@ class _BufferedLineReader:
     Helper class that encapsulates the logic for reading UTF-8 stream data as a series of text lines,
     each of which can be terminated by \n, \r, or \r\n.
     """
+
     @staticmethod
     def lines_from(chunks):
         """
@@ -49,6 +50,7 @@ def lines_from(chunks):
             for line in lines:
                 yield line.decode()
 
+
 class _SSEReader:
     def __init__(
         self,
@@ -59,11 +61,11 @@ def __init__(
         self._lines_source = lines_source
         self._last_event_id = last_event_id
         self._set_retry = set_retry
-    
+
     @property
     def last_event_id(self):
         return self._last_event_id
-    
+
     @property
     def events_and_comments(self):
         event_type = ""