fixup: pr feedback

Signed-off-by: Todd Baert <todd.baert@dynatrace.com>

Author: toddbaert

openfeature/_api.py

@@ -104,13 +104,19 @@ def set_evaluation_context(self, evaluation_context: EvaluationContext) -> None:
             raise GeneralError(error_message="No api level evaluation context")
         self._evaluation_context = evaluation_context
 
+    def clear_evaluation_context(self) -> None:
+        self.set_evaluation_context(EvaluationContext())
+
     # --- Transaction context ---
 
     def set_transaction_context_propagator(
         self, transaction_context_propagator: TransactionContextPropagator
     ) -> None:
         self._transaction_context_propagator = transaction_context_propagator
 
+    def clear_transaction_context_propagator(self) -> None:
+        self.set_transaction_context_propagator(NoOpTransactionContextPropagator())
+
     def get_transaction_context(self) -> EvaluationContext:
         return self._transaction_context_propagator.get_transaction_context()
 

openfeature/_event_support.py

@@ -3,6 +3,7 @@
 import atexit
 import threading
 import typing
+import weakref
 from collections import defaultdict
 from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
@@ -46,9 +47,11 @@ def __init__(self) -> None:
         )
 
         self._client_lock = threading.RLock()
-        self._client_handlers: dict[
+        # WeakKeyDictionary so clients are not retained by the registry; this
+        # avoids memory leaks and a reference cycle between API and clients.
+        self._client_handlers: weakref.WeakKeyDictionary[
             OpenFeatureClient, dict[ProviderEvent, list[EventHandler]]
-        ] = defaultdict(lambda: defaultdict(list))
+        ] = weakref.WeakKeyDictionary()
 
     def run_client_handlers(
         self, client: OpenFeatureClient, event: ProviderEvent, details: EventDetails
@@ -74,17 +77,21 @@ def add_client_handler(
         self, client: OpenFeatureClient, event: ProviderEvent, handler: EventHandler
     ) -> None:
         with self._client_lock:
-            handlers = self._client_handlers[client][event]
-            handlers.append(handler)
+            handlers_by_event = self._client_handlers.setdefault(
+                client, defaultdict(list)
+            )
+            handlers_by_event[event].append(handler)
 
         self._run_immediate_handler(client, event, handler)
 
     def remove_client_handler(
         self, client: OpenFeatureClient, event: ProviderEvent, handler: EventHandler
     ) -> None:
         with self._client_lock:
-            handlers = self._client_handlers[client][event]
-            handlers.remove(handler)
+            handlers_by_event = self._client_handlers.get(client)
+            if handlers_by_event is None:
+                return
+            handlers_by_event[event].remove(handler)
 
     def add_global_handler(
         self,

openfeature/api.py

@@ -9,9 +9,6 @@
 from openfeature.provider import FeatureProvider
 from openfeature.provider.metadata import Metadata
 from openfeature.transaction_context import TransactionContextPropagator
-from openfeature.transaction_context.no_op_transaction_context_propagator import (
-    NoOpTransactionContextPropagator,
-)
 
 __all__ = [
     "add_handler",
@@ -90,7 +87,7 @@ def set_evaluation_context(evaluation_context: EvaluationContext) -> None:
 
 
 def clear_evaluation_context() -> None:
-    set_evaluation_context(EvaluationContext())
+    _default_api.clear_evaluation_context()
 
 
 def set_transaction_context_propagator(
@@ -100,7 +97,7 @@ def set_transaction_context_propagator(
 
 
 def clear_transaction_context_propagator() -> None:
-    set_transaction_context_propagator(NoOpTransactionContextPropagator())
+    _default_api.clear_transaction_context_propagator()
 
 
 def get_transaction_context() -> EvaluationContext:

openfeature/provider/_registry.py

@@ -27,6 +27,14 @@
 
 
 def _register_binding(provider: FeatureProvider, owner: ProviderRegistry) -> None:
+    try:
+        weakref.ref(provider)
+    except TypeError as exc:
+        raise TypeError(
+            f"Provider {type(provider).__name__!r} cannot be tracked because "
+            "it is not weak-referenceable. If your provider class uses "
+            "__slots__, add '__weakref__' to the slots list."
+        ) from exc
     with _binding_lock:
         existing = _provider_bindings.get(provider)
         if existing is not None and existing is not owner:

tests/test_isolated_api.py

@@ -1,7 +1,9 @@
 """Tests for isolated OpenFeature API instances (spec section 1.8)."""
 
+import gc
 import inspect
 import time
+import weakref
 from unittest.mock import MagicMock
 
 import pytest
@@ -12,7 +14,7 @@
 from openfeature.event import ProviderEvent, ProviderEventDetails
 from openfeature.hook import Hook
 from openfeature.isolated import OpenFeatureAPI, create_api
-from openfeature.provider import FeatureProvider, ProviderStatus
+from openfeature.provider import FeatureProvider, Metadata, ProviderStatus
 from openfeature.provider.no_op_provider import NoOpProvider
 from openfeature.transaction_context import ContextVarsTransactionContextPropagator
 
@@ -46,8 +48,10 @@ def test_isolated_instance_is_openfeature_api():
 _ISOLATED_API_PUBLIC_METHODS = (
     "add_handler",
     "add_hooks",
+    "clear_evaluation_context",
     "clear_hooks",
     "clear_providers",
+    "clear_transaction_context_propagator",
     "get_client",
     "get_evaluation_context",
     "get_hooks",
@@ -189,6 +193,37 @@ def test_provider_can_be_rebound_after_being_released():
     assert api2.get_provider() is provider
 
 
+def test_set_provider_rejects_non_weak_referenceable_provider():
+    """Providers must be weak-referenceable so the SDK can track bindings
+    without leaking memory; surfacing this requirement up front (rather than
+    silently skipping the spec 1.8.4 check) avoids hard-to-diagnose bugs."""
+
+    # A direct ``object`` subclass with ``__slots__`` and no ``__weakref__``
+    # entry; instances are not weak-referenceable. Implements the
+    # ``FeatureProvider`` protocol structurally rather than via inheritance
+    # (which would inherit ``__weakref__`` from the parent class).
+    class NotWeakReferenceable:
+        __slots__ = ()
+
+        def attach(self, on_emit):
+            pass
+
+        def detach(self):
+            pass
+
+        def get_metadata(self):
+            return Metadata(name="not-weak-referenceable")
+
+        def get_provider_hooks(self):
+            return []
+
+    provider = NotWeakReferenceable()
+    api_instance = create_api()
+
+    with pytest.raises(TypeError, match="weak-referenceable"):
+        api_instance.set_provider(provider)  # type: ignore[arg-type]
+
+
 # --- Isolated state: hooks ---
 
 
@@ -320,6 +355,25 @@ def test_isolated_event_handlers_do_not_affect_global():
     assert handler.call_count == 0
 
 
+def test_client_handlers_do_not_retain_clients():
+    """Registering an event handler on a client must not keep the client
+    (or its owning API) alive once the user drops their references."""
+    api_instance = create_api()
+    provider = NoOpProvider()
+    api_instance.set_provider(provider)
+
+    client = api_instance.get_client(domain="ephemeral")
+    client.add_handler(ProviderEvent.PROVIDER_CONFIGURATION_CHANGED, MagicMock())
+
+    client_ref = weakref.ref(client)
+    assert client_ref() is client
+
+    del client
+    gc.collect()
+
+    assert client_ref() is None
+
+
 # --- Provider lifecycle on isolated instances ---