fix: Do not report a permanent data source failure as fatal (#52)

A permanent data source failure no longer puts the provider into the
OpenFeature `FATAL` state, so the OpenFeature client keeps evaluating
against the flag data the LaunchDarkly client already has.

- `DataSourceState.OFF` now emits `ErrorCode.GENERAL` instead of
`ErrorCode.PROVIDER_FATAL`
- Matches the Java provider, which reports this as `ERROR`
- Relates to #49

**Requirements**

- [x] I have added test coverage for new or changed functionality
- [x] I have followed the repository's [pull request submission
guidelines](../blob/main/CONTRIBUTING.md#submitting-pull-requests)
- [x] I have validated my changes against all supported platform
versions

<details>
<summary>Implementation details</summary>

**Related issues**

#49 — during an outage, a `401` on an already-established stream took
the data source to `OFF` and OpenFeature evaluations started returning
call-site defaults even though the LaunchDarkly client still had valid
flag data.

**Describe the solution you've provided**

The OpenFeature Python SDK short-circuits evaluation when the provider
status is `FATAL`:

```python
if status == ProviderStatus.FATAL:
    return ProviderFatalError()
```

That means the provider is never asked to evaluate and the call-site
default is returned. `PROVIDER_FATAL` is what moves the provider into
that status, so reporting a permanent data source failure that way
discards flag data the LaunchDarkly client can still serve.
`ErrorCode.GENERAL` keeps the provider in `ERROR`, which still surfaces
the failure through provider events and `get_provider_status()` while
leaving evaluation intact.

**Describe alternatives you've considered**

Leaving the state fatal only when the client never initialized was
considered. It adds state tracking to the provider for little benefit: a
client that never initialized has no flag data, so evaluations already
fall back to defaults with a `PROVIDER_NOT_READY`/`ERROR` reason, and
the `ERROR` status carries the same signal to anything watching provider
events.

**Testing**

Added
`test_evaluations_continue_after_the_data_source_permanently_fails`,
backed by a new `InitializedThenFailingDataSource` fixture that
initializes with flag data, goes `VALID`, then transitions to `OFF` with
a `401`. The test asserts the provider status is `ERROR` and that the
cached flag still evaluates to its real value rather than the call-site
default.

</details>


Link to Devin session:
https://app.devin.ai/sessions/0c452d209ec54b068ba120b4c92b8f6c
Requested by: @kinyoklion

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Overview**
> Stops treating a permanent data source failure (`DataSourceState.OFF`)
as OpenFeature `PROVIDER_FATAL`, so evaluations keep using cached
LaunchDarkly flag data instead of being short-circuited to call-site
defaults.
> 
> `__handle_data_source_status` now emits `ErrorCode.GENERAL`, leaving
the provider in `ERROR` while still surfacing the failure. A new test
initializes flags, then fails the data source with a 401, and asserts
status is `ERROR` and the cached flag still evaluates correctly.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
e0fea34. Bugbot is set up for automated
code reviews on this repo. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>

Author: kinyoklion

ld_openfeature/provider.py

@@ -41,7 +41,10 @@ def __handle_data_source_status(self, status: DataSourceStatus):
         elif state == DataSourceState.OFF:
             error_message = self.__get_message(status,
                                                "the provider has encountered a permanent error or has been shutdown")
-            self.emit_provider_error(ProviderEventDetails(error_code=ErrorCode.PROVIDER_FATAL,
+            # This is not reported as a fatal error. A fatal provider prevents the OpenFeature client
+            # from evaluating flags at all, but the LaunchDarkly client can keep evaluating the flag
+            # data it already has.
+            self.emit_provider_error(ProviderEventDetails(error_code=ErrorCode.GENERAL,
                                                           message=error_message))
         elif state == DataSourceState.INTERRUPTED:
             error_message = self.__get_message(status, "encountered an unknown error")

tests/test_data_sources.py

@@ -74,6 +74,40 @@ def initialized(self):
         return False
 
 
+class InitializedThenFailingDataSource(UpdateProcessor):
+    def __init__(self, config: Config, store, ready: threading.Event):
+        self._data_source_update_sink: Optional[DataSourceUpdateSink] = config.data_source_update_sink
+        self._ready = ready
+
+    def start(self):
+        self._ready.set()
+        self._data_source_update_sink.init(
+            {FEATURES: {"cached-boolean": TestData().data_source().flag("cached-boolean").on(True)._build(1)}})
+        self._data_source_update_sink.update_status(DataSourceState.VALID, None)
+
+        def data_source_failure():
+            self._data_source_update_sink.update_status(
+                DataSourceState.OFF,
+                DataSourceErrorInfo(
+                    DataSourceErrorKind.ERROR_RESPONSE,
+                    401,
+                    time.time(),
+                    str("Bad things")
+                )
+            )
+
+        threading.Timer(0.1, data_source_failure).start()
+
+    def stop(self):
+        pass
+
+    def is_alive(self):
+        return False
+
+    def initialized(self):
+        return True
+
+
 class StaleDataSource(UpdateProcessor):
     def __init__(self, config: Config, store, ready: threading.Event):
         self._data_source_update_sink: Optional[DataSourceUpdateSink] = config.data_source_update_sink

tests/test_provider.py

@@ -11,10 +11,11 @@
 from openfeature.event import ProviderEvent, EventDetails
 from openfeature.exception import ErrorCode
 from openfeature.flag_evaluation import Reason
+from openfeature.provider import ProviderStatus
 from openfeature import api
 
 from ld_openfeature import LaunchDarklyProvider, Config
-from tests.test_data_sources import FailingDataSource, StaleDataSource, UpdatingDataSource, DelayedFailingDataSource
+from tests.test_data_sources import FailingDataSource, InitializedThenFailingDataSource, StaleDataSource, UpdatingDataSource, DelayedFailingDataSource
 
 
 @pytest.fixture
@@ -232,6 +233,28 @@ def handle_status(details: EventDetails):
     api.shutdown()
 
 
+def test_evaluations_continue_after_the_data_source_permanently_fails():
+    thread_event = threading.Event()
+
+    def handle_status(details: EventDetails):
+        if details.provider_name == 'launchdarkly-openfeature-server':
+            thread_event.set()
+
+    api.add_handler(ProviderEvent.PROVIDER_ERROR, handle_status)
+
+    provider = LaunchDarklyProvider(
+        Config("", update_processor_class=InitializedThenFailingDataSource, send_events=False))
+    api.set_provider(provider)
+    client = api.get_client()
+
+    assert thread_event.wait(timeout=5)
+
+    assert client.get_provider_status() == ProviderStatus.ERROR
+    assert client.get_boolean_value("cached-boolean", False, EvaluationContext('user-key')) is True
+
+    api.shutdown()
+
+
 def test_provider_emits_stale_event():
     thread_event = threading.Event()