launchdarkly-eventsource 1.5.1__py3-none-any.whl

launchdarkly_eventsource-1.5.1.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: launchdarkly-eventsource
+Version: 1.5.1
+Summary: LaunchDarkly SSE Client
+License: Apache-2.0
+License-File: LICENSE
+Author: LaunchDarkly
+Author-email: dev@launchdarkly.com
+Requires-Python: >=3.9
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: urllib3 (>=1.26.0,<3)
+Project-URL: Documentation, https://launchdarkly-sse-client-library.readthedocs.io/en/latest/
+Project-URL: Homepage, https://docs.launchdarkly.com/sdk/server-side/python
+Project-URL: Repository, https://github.com/launchdarkly/python-eventsource
+Description-Content-Type: text/markdown
+
+# LaunchDarkly SSE Client for Python
+
+[![Run CI](https://github.com/launchdarkly/python-eventsource/actions/workflows/ci.yml/badge.svg)](https://github.com/launchdarkly/python-eventsource/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/launchdarkly-eventsource.svg?maxAge=2592000)](https://pypi.python.org/pypi/launchdarkly-eventsource)
+[![readthedocs](https://readthedocs.org/projects/launchdarkly-sse-client-library/badge/)](https://launchdarkly-sse-client-library.readthedocs.io/en/latest/)
+
+## Overview
+
+The `launchdarkly/python-eventsource` package allows Python developers to consume Server-Sent-Events (SSE) from a remote API. The SSE specification is defined here: [https://html.spec.whatwg.org/multipage/server-sent-events.html](https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events)
+
+This package's primary purpose is to support the [LaunchDarkly SDK for Python](https://github.com/launchdarkly/python-server-sdk), but it can be used independently. In its simplest configuration, it emulates the behavior of the EventSource API as defined in the SSE specification, with the addition of exponential backoff behavior for retries. However, it also includes optional features used by LaunchDarkly SDKs that are not part of the core specification, such as:
+
+* Customizing the backoff/jitter behavior.
+* Setting read timeouts, custom headers, and other HTTP request properties.
+* Specifying that connections should be retried under circumstances where the standard EventSource behavior would not retry them, such as if the server returns an HTTP error status.
+
+This is a synchronous implementation which blocks the caller's thread when reading events or reconnecting. By default, it uses `urllib3` to make HTTP requests, but it can be configured to read any input stream.
+
+## Supported Python versions
+
+This version of the package is compatible with Python 3.9 and higher.
+
+## Contributing
+
+We encourage pull requests and other contributions from the community. Check out our [contributing guidelines](CONTRIBUTING.md) for instructions on how to contribute to this SDK.
+
+## About LaunchDarkly
+
+* LaunchDarkly is a continuous delivery platform that provides feature flags as a service and allows developers to iterate quickly and safely. We allow you to easily flag your features and manage them from the LaunchDarkly dashboard.  With LaunchDarkly, you can:
+    * Roll out a new feature to a subset of your users (like a group of users who opt-in to a beta tester group), gathering feedback and bug reports from real-world use cases.
+    * Gradually roll out a feature to an increasing percentage of users, and track the effect that the feature has on key metrics (for instance, how likely is a user to complete a purchase if they have feature A versus feature B?).
+    * Turn off a feature that you realize is causing performance problems in production, without needing to re-deploy, or even restart the application with a changed configuration file.
+    * Grant access to certain features based on user attributes, like payment plan (eg: users on the ‘gold’ plan get access to more features than users in the ‘silver’ plan). Disable parts of your application to facilitate maintenance, without taking everything offline.
+* LaunchDarkly provides feature flag SDKs for a wide variety of languages and technologies. Read [our documentation](https://docs.launchdarkly.com/sdk) for a complete list.
+* Explore LaunchDarkly
+    * [launchdarkly.com](https://www.launchdarkly.com/ "LaunchDarkly Main Website") for more information
+    * [docs.launchdarkly.com](https://docs.launchdarkly.com/  "LaunchDarkly Documentation") for our documentation and SDK reference guides
+    * [apidocs.launchdarkly.com](https://apidocs.launchdarkly.com/  "LaunchDarkly API Documentation") for our API documentation
+    * [blog.launchdarkly.com](https://blog.launchdarkly.com/  "LaunchDarkly Blog Documentation") for the latest product updates
+

launchdarkly_eventsource-1.5.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+ld_eventsource/__init__.py,sha256=Rj-tMSwF3Ca2ZBgVrGVK0FXbf9w_MV-Xcl4KN_ES_oQ,40
+ld_eventsource/actions.py,sha256=Ulq35iWycziB25AXiX5upXWuiH4XVtJRRsOMwHWbXtM,5573
+ld_eventsource/config/__init__.py,sha256=u2RNWRh8CFGLChAuYGmkyRBxAAHCA93FPC9rZJjCTh8,210
+ld_eventsource/config/connect_strategy.py,sha256=gwv3c3TKJ7Lr2PjEdcDOCIyIIlF5vibNOzkLkCmoftk,5538
+ld_eventsource/config/error_strategy.py,sha256=WQn41yVm4Aej_0poAQNi20Eky2z19U_71r0cVL8UVnc,5989
+ld_eventsource/config/retry_delay_strategy.py,sha256=CzSBD00GjVoMGAN97Y88rOUoEc8ngNafklaOWiVQOuU,6041
+ld_eventsource/errors.py,sha256=FN4X_ElLnQvasnojg6iWVFdKmmWkPXkZattQdhaL2qw,1903
+ld_eventsource/http.py,sha256=vMw_CPBDWpt-4C5Sn5KjkTIIhaJU8rQ8wubXUoboPpk,4173
+ld_eventsource/reader.py,sha256=i4TOH_HF5RpZO1dL3BXrTNtY7ns-w7ESDyQawhfsBUw,4591
+ld_eventsource/sse_client.py,sha256=9L-Od6r5QscLIf-znGtMgZbFTFr4SEDFfT_rdWZ22QI,15424
+ld_eventsource/testing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ld_eventsource/testing/helpers.py,sha256=PnBjZDuJFzyVNWjMQe7q4vh_eTVAas_XRiJ34p-22RE,2583
+ld_eventsource/testing/http_util.py,sha256=g4CDbmnN07v35mwmbWdsm3NO9DmcC0couuSil_96FRA,6181
+ld_eventsource/testing/test_error_strategy.py,sha256=wGOvb5a_qCEmkX34urYLDwoaQB-I637kjGH775IsHDs,1206
+ld_eventsource/testing/test_headers.py,sha256=DlNhbJzxzKQAa55h-yPmwsREdjj63joyjtvbKgHkvLw,7245
+ld_eventsource/testing/test_http_connect_strategy.py,sha256=YOSnZp7H2-ZgE0sqiCZ3eLfYrJZ_eTsxkPdvxoSfEhI,9836
+ld_eventsource/testing/test_http_connect_strategy_with_sse_client.py,sha256=0jRGnkbA7elgPkyysddw7OAQl2KAZf6gGRNhHvGET_M,5098
+ld_eventsource/testing/test_reader.py,sha256=IzQcfY2617YQh09Lhdb7z3IVQwJ72DRGTOP47sdF8wI,4261
+ld_eventsource/testing/test_retry_delay_strategy.py,sha256=kC8drzR5dhqSVyCpYMvZqOvMIzWHw_1cyOUOSCJDi1Q,2932
+ld_eventsource/testing/test_sse_client_basic.py,sha256=kyq71hPwprytgi35xzIDoDQBcbHzXekSR-zxG8E7-uM,2853
+ld_eventsource/testing/test_sse_client_retry.py,sha256=q-P-mOtfWVavQQ5BjOUExJmsUUsl1Oz9riznlALqd6o,5684
+ld_eventsource/version.py,sha256=Y4RerTQOBLCwfc5jQyTzIRJmt11UdnzYO783pXhWZ7Y,46
+launchdarkly_eventsource-1.5.1.dist-info/METADATA,sha256=KbaCiGfQ4N3PEIGHqEfFKPvyOz57fixLO-rGyhzIdCI,5126
+launchdarkly_eventsource-1.5.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+launchdarkly_eventsource-1.5.1.dist-info/licenses/LICENSE,sha256=LNd6xXgmOpKMYnrqSSyhw2lTAfKVet-9Qd15tQbpzC8,557
+launchdarkly_eventsource-1.5.1.dist-info/RECORD,,

launchdarkly_eventsource-1.5.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

launchdarkly_eventsource-1.5.1.dist-info/licenses/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2021 Catamorphic, Co.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

ld_eventsource/__init__.py

@@ -0,0 +1 @@
+from ld_eventsource.sse_client import *

ld_eventsource/actions.py

@@ -0,0 +1,176 @@
+import json
+from typing import Any, Dict, Optional
+
+from ld_eventsource.errors import ExceptionWithHeaders
+
+
+class Action:
+    """
+    Base class for objects that can be returned by :attr:`.SSEClient.all`.
+    """
+
+    pass
+
+
+class Event(Action):
+    """
+    An event received by :class:`.SSEClient`.
+
+    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,
+    ):
+        self._event = event
+        self._data = data
+        self._id = id
+        self._last_event_id = last_event_id
+
+    @property
+    def event(self) -> str:
+        """
+        The event type, or "message" if not specified.
+        """
+        return self._event
+
+    @property
+    def data(self) -> str:
+        """
+        The event data.
+        """
+        return self._data
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        The value of the ``id:`` field for this event, or `None` if omitted.
+        """
+        return self._id
+
+    @property
+    def last_event_id(self) -> Optional[str]:
+        """
+        The value of the most recent ``id:`` field of an event seen in this stream so far.
+        """
+        return self._last_event_id
+
+    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
+        )
+
+    def __repr__(self):
+        return "Event(event=\"%s\", data=%s, id=%s, last_event_id=%s)" % (
+            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),
+        )
+
+
+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
+
+    @property
+    def comment(self) -> str:
+        """
+        The comment text, not including the leading colon.
+        """
+        return self._comment
+
+    def __eq__(self, other):
+        return isinstance(other, Comment) and self._comment == other._comment
+
+    def __repr__(self):
+        return ":" + self._comment
+
+
+class Start(Action):
+    """
+    Indicates that :class:`.SSEClient` has successfully connected to a stream.
+
+    Instances of this class are only available from :attr:`.SSEClient.all`.
+    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``.
+
+    Each ``Start`` action may include HTTP response headers from the connection. These headers
+    are available via the :attr:`headers` property. On reconnection, a new ``Start`` will be
+    emitted with the headers from the new connection, which may differ from the previous one.
+    """
+
+    def __init__(self, headers: Optional[Dict[str, Any]] = None):
+        self._headers = headers
+
+    @property
+    def headers(self) -> Optional[Dict[str, Any]]:
+        """
+        The HTTP response headers from the stream connection, if available.
+
+        The headers dict uses case-insensitive keys (via urllib3's HTTPHeaderDict).
+
+        :return: the response headers, or ``None`` if not available
+        """
+        return self._headers
+
+
+class Fault(Action):
+    """
+    Indicates that :class:`.SSEClient` encountered an error or end of stream.
+
+    Instances of this class are only available from :attr:`.SSEClient.all`.
+
+    If you receive a Fault, the SSEClient is now in an inactive state since either a
+    connection attempt has failed or an existing connection has been closed. The SSEClient
+    will attempt to reconnect if you either call :meth:`.SSEClient.start()`
+    or simply continue reading events after this point.
+
+    When the error includes HTTP response headers (such as for :class:`.HTTPStatusError`
+    or :class:`.HTTPContentTypeError`), they are accessible via the :attr:`headers` property.
+    """
+
+    def __init__(self, error: Optional[Exception]):
+        self.__error = error
+
+    @property
+    def error(self) -> Optional[Exception]:
+        """
+        The exception that caused the stream to fail, if any. If this is ``None``, it means
+        that the stream simply ran out of data, i.e. the server shut down the connection
+        in an orderly way after sending an EOF chunk as defined by chunked transfer encoding.
+        """
+        return self.__error
+
+    @property
+    def headers(self) -> Optional[Dict[str, Any]]:
+        """
+        The HTTP response headers from the failed connection, if available.
+
+        This property returns headers when the error is an exception that includes them,
+        such as :class:`.HTTPStatusError` or :class:`.HTTPContentTypeError`. For other
+        error types or when the stream ended normally, this returns ``None``.
+
+        :return: the response headers, or ``None`` if not available
+        """
+        if isinstance(self.__error, ExceptionWithHeaders):
+            return self.__error.headers
+        return None

ld_eventsource/config/__init__.py

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

ld_eventsource/config/connect_strategy.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from logging import Logger
+from typing import Any, Callable, Dict, Iterator, Optional, Union
+
+from urllib3 import PoolManager
+
+from ld_eventsource.http import (DynamicQueryParams, _HttpClientImpl,
+                                 _HttpConnectParams)
+
+
+class ConnectStrategy:
+    """
+    An abstraction for how :class:`.SSEClient` should obtain an input stream.
+
+    The default implementation is :meth:`http()`, which makes HTTP requests with ``urllib3``.
+    Or, if you want to consume an input stream from some other source, you can create your own
+    subclass of :class:`ConnectStrategy`.
+
+    Instances of this class should be immutable and should not contain any state that is specific
+    to one active stream. The :class:`ConnectionClient` that they produce is stateful and belongs
+    to a single :class:`.SSEClient`.
+    """
+
+    def create_client(self, logger: Logger) -> ConnectionClient:
+        """
+        Creates a client instance.
+
+        This is called once when an :class:`.SSEClient` is created. The SSEClient returns the
+        returned :class:`ConnectionClient` and uses it to perform all subsequent connection attempts.
+
+        :param logger: the logger being used by the SSEClient
+        """
+        raise NotImplementedError("ConnectStrategy base class cannot be used by itself")
+
+    @staticmethod
+    def http(
+        url: str,
+        headers: Optional[dict] = None,
+        pool: Optional[PoolManager] = None,
+        urllib3_request_options: Optional[dict] = None,
+        query_params: Optional[DynamicQueryParams] = None
+    ) -> ConnectStrategy:
+        """
+        Creates the default HTTP implementation, specifying request parameters.
+
+        :param url: the stream URL
+        :param headers: optional HTTP headers to add to the request
+        :param pool: optional urllib3 ``PoolManager`` to provide an HTTP client
+        :param urllib3_request_options: optional ``kwargs`` to add to the ``request`` call; these
+            can include any parameters supported by ``urllib3``, such as ``timeout``
+        :param query_params: optional callable that can be used to affect query parameters
+            dynamically for each connection attempt
+        """
+        return _HttpConnectStrategy(
+            _HttpConnectParams(url, headers, pool, urllib3_request_options, query_params)
+        )
+
+
+class ConnectionClient:
+    """
+    An object provided by :class:`.ConnectStrategy` that is retained by a single
+    :class:`.SSEClient` to perform all connection attempts by that instance.
+
+    For the default HTTP implementation, this represents an HTTP connection pool.
+    """
+
+    def connect(self, last_event_id: Optional[str]) -> ConnectionResult:
+        """
+        Attempts to connect to a stream. Raises an exception if unsuccessful.
+
+        :param last_event_id: the current value of :attr:`SSEClient.last_event_id`
+            (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"
+        )
+
+    def close(self):
+        """
+        Does whatever is necessary to release resources when the SSEClient is closed.
+        """
+        pass
+
+    def __enter__(self):
+        return self
+
+    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], headers: Optional[Dict[str, Any]] = None):
+        self.__stream = stream
+        self.__closer = closer
+        self.__headers = headers
+
+    @property
+    def stream(self) -> Iterator[bytes]:
+        """
+        An iterator that returns chunks of data.
+        """
+        return self.__stream
+
+    @property
+    def headers(self) -> Optional[Dict[str, Any]]:
+        """
+        The HTTP response headers, if available.
+
+        For HTTP connections, this contains the headers from the SSE stream response.
+        For non-HTTP connections, this will be ``None``.
+
+        The headers dict uses case-insensitive keys (via urllib3's HTTPHeaderDict).
+        """
+        return self.__headers
+
+    def close(self):
+        """
+        Does whatever is necessary to release the connection.
+        """
+        if self.__closer:
+            self.__closer()
+            self.__closer = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+
+# _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
+
+    def create_client(self, logger: Logger) -> ConnectionClient:
+        return _HttpConnectionClient(self.__params, logger)
+
+
+class _HttpConnectionClient(ConnectionClient):
+    def __init__(self, params: _HttpConnectParams, logger: Logger):
+        self.__impl = _HttpClientImpl(params, logger)
+
+    def connect(self, last_event_id: Optional[str]) -> ConnectionResult:
+        stream, closer, headers = self.__impl.connect(last_event_id)
+        return ConnectionResult(stream, closer, headers)
+
+    def close(self):
+        self.__impl.close()
+
+
+__all__ = ['ConnectStrategy', 'ConnectionClient', 'ConnectionResult']

ld_eventsource/config/error_strategy.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import time
+from typing import Callable, Optional, Tuple
+
+
+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
+    package such as :class:`.HTTPStatusError`.
+
+    The two options for the result are:
+
+    * :const:`FAIL`: This means that SSEClient should throw an exception to the caller-- or, in
+      the case of a stream ending without an error, it should simply stop iterating through events.
+    * :const:`CONTINUE`: This means that you intend to keep reading events, so SSEClient should
+      transparently retry the connection. If you are reading from :attr:`.SSEClient.all`,
+      you will also receive a :class:`.Fault` describing the error.
+
+    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
+    for SSEClient to reset to the original error-handling state when appropriate by simply reusing
+    the original instance.
+    """
+
+    FAIL = True
+    CONTINUE = False
+
+    def apply(self, exception: Optional[Exception]) -> Tuple[bool, ErrorStrategy]:
+        """Applies the strategy to determine what to do after a failure.
+
+        :param exception: an exception, or ``None`` if the stream simply ended
+        :return: a tuple where the first element is either :const:`FAIL` to raise an exception
+            or :const:`CONTINUE` to continue, and the second element is the strategy object to
+            use next time (which could be ``self``)
+        """
+        raise NotImplementedError("ErrorStrategy base class cannot be used by itself")
+
+    @staticmethod
+    def always_fail() -> ErrorStrategy:
+        """
+        Specifies that SSEClient should always treat an error as a stream failure. This is the
+        default behavior if you do not configure another.
+        """
+        return _LambdaErrorStrategy(lambda e: (ErrorStrategy.FAIL, None))
+
+    @staticmethod
+    def always_continue() -> ErrorStrategy:
+        """
+        Specifies that SSEClient should never raise an exception, but should transparently retry
+        or, if :attr:`.SSEClient.all` is being used, return the error as a :class:`.Fault`.
+
+        Be aware that using this mode could cause connection attempts to block indefinitely if
+        the server is unavailable.
+        """
+        return _LambdaErrorStrategy(lambda e: (ErrorStrategy.CONTINUE, None))
+
+    @staticmethod
+    def continue_with_max_attempts(max_attempts: int) -> ErrorStrategy:
+        """
+        Specifies that SSEClient should automatically retry after an error for up to this
+        number of consecutive attempts, but should fail after that point.
+
+        :param max_attempts: the maximum number of consecutive retries
+        """
+        return _MaxAttemptsErrorStrategy(max_attempts, 0)
+
+    @staticmethod
+    def continue_with_time_limit(max_time: float) -> ErrorStrategy:
+        """
+        Specifies that SSEClient should automatically retry after a failure and can retry
+        repeatedly until this amount of time has elapsed, but should fail after that point.
+
+        :param max_time: the time limit, in seconds
+        """
+        return _TimeLimitErrorStrategy(max_time, 0)
+
+    @staticmethod
+    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.
+
+        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``.
+        """
+        return _LambdaErrorStrategy(fn)
+
+
+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()),
+            )
+        if (time.time() - self.__start_time) < self.__max_time:
+            return (ErrorStrategy.CONTINUE, self)
+        return (ErrorStrategy.FAIL, self)
+
+
+__all__ = ['ErrorStrategy']