growthbook 1.4.10__tar.gz → 2.1.0__tar.gz

{growthbook-1.4.10/growthbook.egg-info → growthbook-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.4.10
+Version: 2.1.0
 Summary: Powerful Feature flagging and A/B testing for Python apps
 Home-page: https://github.com/growthbook/growthbook-python
 Author: GrowthBook

{growthbook-1.4.10 → growthbook-2.1.0}/growthbook/__init__.py

@@ -18,5 +18,5 @@ from .plugins import (
 )
 
 # x-release-please-start-version
-__version__ = "1.4.10"
+__version__ = "2.1.0"
 # x-release-please-end

{growthbook-1.4.10 → growthbook-2.1.0}/growthbook/core.py

@@ -178,6 +178,24 @@ def evalOperatorCondition(operator, attributeValue, conditionValue, savedGroups)
             return bool(r.search(attributeValue))
         except Exception:
             return False
+    elif operator == "$regexi":
+        try:
+            r = re.compile(conditionValue, re.IGNORECASE)
+            return bool(r.search(attributeValue))
+        except Exception:
+            return False
+    elif operator == "$notRegex":
+        try:
+            r = re.compile(conditionValue)
+            return not bool(r.search(attributeValue))
+        except Exception:
+            return False
+    elif operator == "$notRegexi":
+        try:
+            r = re.compile(conditionValue, re.IGNORECASE)
+            return not bool(r.search(attributeValue))
+        except Exception:
+            return False
     elif operator == "$in":
         if not type(conditionValue) is list:
             return False

{growthbook-1.4.10 → growthbook-2.1.0}/growthbook/growthbook.py

@@ -782,7 +782,7 @@ class GrowthBook(object):
         )
 
         if features:
-            self.setFeatures(features)
+            self.set_features(features)
 
         # Register for automatic feature updates when cache expires
         if self._client_key:
@@ -813,7 +813,7 @@ class GrowthBook(object):
             self._api_host, self._client_key, self._decryption_key, self._cache_ttl
         )
         if response is not None and "features" in response.keys():
-            self.setFeatures(response["features"])
+            self.set_features(response["features"])
 
         if response is not None and "savedGroups" in response:
             self._saved_groups = response["savedGroups"]
@@ -828,7 +828,7 @@ class GrowthBook(object):
 
         if features is not None:
             if "features" in features:
-                self.setFeatures(features["features"])
+                self.set_features(features["features"])
             if "savedGroups" in features:
                 self._saved_groups = features["savedGroups"]
             feature_repo.save_in_cache(self._client_key, features, self._cache_ttl)
@@ -842,7 +842,7 @@ class GrowthBook(object):
 
         if data is not None:
             if "features" in data:
-                self.setFeatures(data["features"])
+                self.set_features(data["features"])
             if "savedGroups" in data:
                 self._saved_groups = data["savedGroups"]
             feature_repo.save_in_cache(self._client_key, features, self._cache_ttl)

{growthbook-1.4.10 → growthbook-2.1.0}/growthbook/growthbook_client.py

@@ -169,40 +169,78 @@ class EnhancedFeatureRepository(FeatureRepository, metaclass=SingletonMeta):
             if callback in self._callbacks:
                 self._callbacks.remove(callback)
 
+    """
+    _start_sse_refresh flow mimics a bridge pattern to connect a blocking, synchronous background thread 
+    (the SSEClient) with your non-blocking, async main loop.
+
+    Bridge - _maintain_sse_connection - runs on the main async loop, calls `startAutoRefresh` (which in turn spawns a thread)
+    and waits indefinitely. (Awaiting a Future suspends the coroutine, costing zero CPU)
+
+    The SSEClient runs in a separate thread, makes a blocking HTTP request, and invokes `on_event` synchronously.
+
+    The Hand off - when the event arrives (we're still on the background thread), sse_handler uses `asyncio.run_coroutine_threadsafe` 
+    to schedule the async processing `_handle_sse_event` onto the main event loop.
+    """
     async def _start_sse_refresh(self) -> None:
         """Start SSE-based feature refresh"""
         with self._refresh_lock:
             if self._refresh_task is not None:  # Already running
                 return
 
-            async def sse_handler(event_data: Dict[str, Any]) -> None:
+            # SSEClient invokes `on_event` synchronously from a background thread.
+            async def _handle_sse_event(event_data: Dict[str, Any]) -> None:
                 try:
-                    if event_data['type'] == 'features-updated':
+                    event_type = event_data.get("type")
+                    if event_type == "features-updated":
                         response = await self.load_features_async(
                             self._api_host, self._client_key, self._decryption_key, self._cache_ttl
                         )
                         if response is not None:
                             await self._handle_feature_update(response)
-                    elif event_data['type'] == 'features':
-                        await self._handle_feature_update(event_data['data'])
+                    elif event_type == "features":
+                        await self._handle_feature_update(event_data.get("data", {}))
                 except Exception:
-                    traceback.print_exc()
+                    logger.exception("Error handling SSE event")
 
-            # Start the SSE connection task
-            self._refresh_task = asyncio.create_task(
-                self._maintain_sse_connection(sse_handler)
-            )
+            main_loop = asyncio.get_running_loop()
 
-    async def _maintain_sse_connection(self, handler: Callable) -> None:
-        """Maintain SSE connection with automatic reconnection"""
-        while not self._stop_event.is_set():
-            try:
-                await self.startAutoRefresh(self._api_host, self._client_key, handler)
-            except Exception as e:
-                if not self._stop_event.is_set():
-                    delay = self._backoff.next_delay()
-                    logger.error(f"SSE connection lost, reconnecting in {delay:.2f}s: {str(e)}")
-                    await asyncio.sleep(delay)
+            # We must not pass an `async def` callback here (it would never be awaited).
+            def sse_handler(event_data: Dict[str, Any]) -> None:
+                # Schedule async processing onto the main event loop.
+                try:
+                    asyncio.run_coroutine_threadsafe(_handle_sse_event(event_data), main_loop)
+                except Exception:
+                    logger.exception("Failed to schedule SSE event handler")
+
+            async def _maintain_sse_connection() -> None:
+                """
+                Start SSE streaming and keep the task alive until cancelled.
+                """
+                try:
+                    # NOTE: `startAutoRefresh` is synchronous and starts a background thread.
+                    self.startAutoRefresh(self._api_host, self._client_key, sse_handler)
+                    
+                    # Wait indefinitely until the task is cancelled - basically saying "Keep this service 'active' until someone cancels me."
+                    # reconnection logic is handled inside SSEClient's thread
+                    await asyncio.Future()
+                except asyncio.CancelledError:
+                    # Normal shutdown flow
+                    raise
+                except Exception:
+                    logger.exception("Unexpected error in SSE lifecycle task")
+                finally:
+                    try:
+                        # stopAutoRefresh blocks joining a thread, so it needs to be run in executor
+                        # to avoid blocking the async event loop
+                        await main_loop.run_in_executor(
+                            None, 
+                            lambda: self.stopAutoRefresh(timeout=10)
+                        )
+                    except Exception:
+                        logger.exception("Failed to stop SSE auto-refresh")
+
+            # Start a task that owns the SSE lifecycle and cleanup.
+            self._refresh_task = asyncio.create_task(_maintain_sse_connection())
 
     async def _start_http_refresh(self, interval: int = 60) -> None:
         """Enhanced HTTP polling with backoff"""
@@ -261,6 +299,12 @@ class EnhancedFeatureRepository(FeatureRepository, metaclass=SingletonMeta):
     async def stop_refresh(self) -> None:
         """Clean shutdown of refresh tasks"""
         self._stop_event.set()
+        # Ensure any SSE background thread is stopped as well.
+        try:
+            self.stopAutoRefresh(timeout=10)
+        except Exception:
+            # Best-effort cleanup; task cancellation below will proceed.
+            logger.exception("Error stopping SSE auto-refresh")
         if self._refresh_task:
             # Cancel the task
             self._refresh_task.cancel()

{growthbook-1.4.10 → growthbook-2.1.0}/growthbook/plugins/growthbook_tracking.py

@@ -132,8 +132,8 @@ class GrowthBookTrackingPlugin(GrowthBookPlugin):
         """Setup feature evaluation tracking."""
         original_eval_feature = gb_instance.eval_feature
         
-        def eval_feature_wrapper(key: str):
-            result = original_eval_feature(key)
+        def eval_feature_wrapper(key: str, *args, **kwargs):
+            result = original_eval_feature(key, *args, **kwargs)
             self._track_feature_evaluated(key, result, gb_instance)
             return result
         

{growthbook-1.4.10 → growthbook-2.1.0/growthbook.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.4.10
+Version: 2.1.0
 Summary: Powerful Feature flagging and A/B testing for Python apps
 Home-page: https://github.com/growthbook/growthbook-python
 Author: GrowthBook

{growthbook-1.4.10 → growthbook-2.1.0}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.4.10
+current_version = 2.1.0
 commit = True
 tag = True
 

{growthbook-1.4.10 → growthbook-2.1.0}/tests/test_growthbook.py

@@ -117,7 +117,7 @@ def test_decrypt(decrypt_data):
 def test_feature(feature_data):
     _, ctx, key, expected = feature_data
     gb = GrowthBook(**ctx)
-    res = gb.evalFeature(key)
+    res = gb.eval_feature(key)
 
     if "experiment" in expected:
         expected["experiment"] = Experiment(**expected["experiment"]).to_dict()
@@ -726,7 +726,7 @@ def test_stores_assigned_variations_in_the_user():
     gb.run(Experiment(key="my-test", variations=[0, 1]))
     gb.run(Experiment(key="my-test-3", variations=[0, 1]))
 
-    assigned = gb.getAllResults()
+    assigned = gb.get_all_results()
     assignedArr = []
 
     for e in assigned:
@@ -748,17 +748,17 @@ def test_getters_setters():
     featuresInput = {"feature-1": feat.to_dict()}
     attributes = {"id": "123", "url": "/"}
 
-    gb.setFeatures(featuresInput)
-    gb.setAttributes(attributes)
+    gb.set_features(featuresInput)
+    gb.set_attributes(attributes)
 
-    featuresOutput = {k: v.to_dict() for (k, v) in gb.getFeatures().items()}
+    featuresOutput = {k: v.to_dict() for (k, v) in gb.get_features().items()}
 
     assert featuresOutput == featuresInput
-    assert attributes == gb.getAttributes()
+    assert attributes == gb.get_attributes()
 
     newAttrs = {"url": "/hello"}
-    gb.setAttributes(newAttrs)
-    assert newAttrs == gb.getAttributes()
+    gb.set_attributes(newAttrs)
+    assert newAttrs == gb.get_attributes()
 
     gb.destroy()
 
@@ -780,17 +780,17 @@ def test_feature_methods():
         }
     )
 
-    assert gb.isOn("featureOn") is True
-    assert gb.isOff("featureOn") is False
-    assert gb.getFeatureValue("featureOn", 15) == 12
+    assert gb.is_on("featureOn") is True
+    assert gb.is_off("featureOn") is False
+    assert gb.get_feature_value("featureOn", 15) == 12
 
-    assert gb.isOn("featureOff") is False
-    assert gb.isOff("featureOff") is True
-    assert gb.getFeatureValue("featureOff", 10) == 0
+    assert gb.is_on("featureOff") is False
+    assert gb.is_off("featureOff") is True
+    assert gb.get_feature_value("featureOff", 10) == 0
 
-    assert gb.isOn("featureNone") is False
-    assert gb.isOff("featureNone") is True
-    assert gb.getFeatureValue("featureNone", 10) == 10
+    assert gb.is_on("featureNone") is False
+    assert gb.is_off("featureNone") is True
+    assert gb.get_feature_value("featureNone", 10) == 10
 
     gb.destroy()
 

{growthbook-1.4.10 → growthbook-2.1.0}/tests/test_growthbook_client.py

@@ -89,10 +89,16 @@ async def test_sse_connection_lifecycle(mock_options, mock_features_response):
                      "refresh_strategy": FeatureRefreshStrategy.SERVER_SENT_EVENTS})
         )
         
-        with patch('growthbook.growthbook_client.EnhancedFeatureRepository._maintain_sse_connection') as mock_sse:
+        # `startAutoRefresh` is synchronous and should be invoked as part of SSE start-up.
+        # `stopAutoRefresh` should be called during shutdown to stop/join the SSE thread.
+        with patch('growthbook.growthbook_client.EnhancedFeatureRepository.startAutoRefresh') as mock_start, \
+             patch('growthbook.growthbook_client.EnhancedFeatureRepository.stopAutoRefresh') as mock_stop:
             await client.initialize()
-            assert mock_sse.called
+            # Allow the SSE lifecycle task to start and invoke startAutoRefresh
+            await asyncio.sleep(0)
+            assert mock_start.called
             await client.close()
+            assert mock_stop.called
 
 @pytest.mark.asyncio
 async def test_feature_repository_load():