growthbook 1.4.9__tar.gz → 2.0.0__tar.gz

{growthbook-1.4.9/growthbook.egg-info → growthbook-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.4.9
+Version: 2.0.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.9 → growthbook-2.0.0}/growthbook/__init__.py

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

{growthbook-1.4.9 → growthbook-2.0.0}/growthbook/growthbook.py

@@ -409,16 +409,35 @@ class FeatureRepository(object):
                 self._notify_feature_update_callbacks(res)
                 return res
         return cached
+    
+    @property
+    def user_agent_suffix(self) -> Optional[str]:
+        return getattr(self, "_user_agent_suffix", None)
+        
+    @user_agent_suffix.setter
+    def user_agent_suffix(self, value: Optional[str]) -> None:
+        self._user_agent_suffix = value
 
     # Perform the GET request (separate method for easy mocking)
     def _get(self, url: str, headers: Optional[Dict[str, str]] = None):
         self.http = self.http or PoolManager()
         return self.http.request("GET", url, headers=headers or {})
+    
+    def _get_headers(self, client_key: str, existing_headers: Dict[str, str] = None) -> Dict[str, str]:
+        headers = existing_headers or {}
+        headers['Accept-Encoding'] = "gzip, deflate"
+        
+        # Add User-Agent with optional suffix
+        ua = "Gb-Python"
+        ua += f"-{self.user_agent_suffix}" if self.user_agent_suffix else f"-{client_key[-4:]}"
+        headers['User-Agent'] = ua
+            
+        return headers
 
     def _fetch_and_decode(self, api_host: str, client_key: str) -> Optional[Dict]:
         url = self._get_features_url(api_host, client_key)
-        headers: Dict[str, str] = {}
-        headers['Accept-Encoding'] = "gzip, deflate, br"
+        headers = self._get_headers(client_key)
+        logger.debug(f"Fetching features from {url} with headers {headers}")
         
         # Check if we have a cached ETag for this URL
         cached_etag = None
@@ -473,13 +492,13 @@ class FeatureRepository(object):
             
             return decoded  # type: ignore[no-any-return]
         except Exception as e:
-            logger.warning(f"Failed to decode feature JSON from GrowthBook API: {e}")
+            logger.error(f"Failed to decode feature JSON from GrowthBook API: {e}")
             return None
         
     async def _fetch_and_decode_async(self, api_host: str, client_key: str) -> Optional[Dict]:
         url = self._get_features_url(api_host, client_key)
-        headers: Dict[str, str] = {}
-        headers['Accept-Encoding'] = "gzip, deflate, br"
+        headers = self._get_headers(client_key=client_key)
+        logger.debug(f"[Async] Fetching features from {url} with headers {headers}")
         
         # Check if we have a cached ETag for this URL
         cached_etag = None
@@ -535,7 +554,7 @@ class FeatureRepository(object):
             logger.warning(f"HTTP request failed: {e}")
             return None
         except Exception as e:
-            logger.warning("Failed to decode feature JSON from GrowthBook API: %s", e)
+            logger.error(f"Failed to decode feature JSON from GrowthBook API: {e}")
             return None
         
     def decrypt_response(self, data, decryption_key: str):
@@ -763,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:
@@ -794,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"]
@@ -809,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)
@@ -823,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)
@@ -1134,6 +1153,16 @@ class GrowthBook(object):
             except Exception as e:
                 logger.error(f"Failed to initialize plugin {plugin}: {e}")
 
+    @property
+    def user_agent_suffix(self) -> Optional[str]:
+        """Get the suffix appended to the User-Agent header"""
+        return feature_repo.user_agent_suffix
+        
+    @user_agent_suffix.setter
+    def user_agent_suffix(self, value: Optional[str]) -> None:
+        """Set a suffix to be appended to the User-Agent header"""
+        feature_repo.user_agent_suffix = value
+
     def _cleanup_plugins(self) -> None:
         """Cleanup all initialized plugins."""
         for plugin in self._initialized_plugins:

{growthbook-1.4.9 → growthbook-2.0.0}/growthbook/growthbook_client.py

@@ -9,7 +9,7 @@ import asyncio
 import threading
 import traceback
 from datetime import datetime
-from growthbook import FeatureRepository
+from growthbook import FeatureRepository, feature_repo
 from contextlib import asynccontextmanager
 
 from .core import eval_feature as core_eval_feature, run_experiment
@@ -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()
@@ -569,7 +613,6 @@ class GrowthBookClient:
             self._tracked.clear()
         with self._subscriptions_lock:
             self._subscriptions.clear()
-
         # Clear context
         async with self._context_lock:
             self._global_context = None
@@ -577,6 +620,16 @@ class GrowthBookClient:
         # Cleanup plugins
         self._cleanup_plugins()
 
+    @property
+    def user_agent_suffix(self) -> Optional[str]:
+        """Get the suffix appended to the User-Agent header"""
+        return feature_repo.user_agent_suffix
+        
+    @user_agent_suffix.setter
+    def user_agent_suffix(self, value: Optional[str]) -> None:
+        """Set a suffix to be appended to the User-Agent header"""
+        feature_repo.user_agent_suffix = value
+
     def _initialize_plugins(self) -> None:
         """Initialize all tracking plugins with this GrowthBookClient instance."""
         for plugin in self._tracking_plugins:

{growthbook-1.4.9 → growthbook-2.0.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.9 → growthbook-2.0.0/growthbook.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.4.9
+Version: 2.0.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.9 → growthbook-2.0.0}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.4.9
+current_version = 2.0.0
 commit = True
 tag = True
 

{growthbook-1.4.9 → growthbook-2.0.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.9 → growthbook-2.0.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():