growthbook 1.4.2__tar.gz → 1.4.4__tar.gz

{growthbook-1.4.2/growthbook.egg-info → growthbook-1.4.4}/PKG-INFO

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

{growthbook-1.4.2 → growthbook-1.4.4}/growthbook/__init__.py

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

{growthbook-1.4.2 → growthbook-1.4.4}/growthbook/growthbook.py

@@ -100,7 +100,8 @@ class InMemoryFeatureCache(AbstractFeatureCache):
     def set(self, key: str, value: Dict, ttl: int) -> None:
         if key in self.cache:
             self.cache[key].update(value)
-        self.cache[key] = CacheEntry(value, ttl)
+        else:
+            self.cache[key] = CacheEntry(value, ttl)
 
     def clear(self) -> None:
         self.cache.clear()
@@ -151,17 +152,32 @@ class SSEClient:
         self._sse_thread = threading.Thread(target=self._run_sse_channel)
         self._sse_thread.start()
 
-    def disconnect(self):
+    def disconnect(self, timeout=10):
+        """Gracefully disconnect with timeout"""
+        logger.debug("Initiating SSE client disconnect")
         self.is_running = False
+        
         if self._loop and self._loop.is_running():
-            future = asyncio.run_coroutine_threadsafe(self._stop_session(), self._loop)
+            future = asyncio.run_coroutine_threadsafe(self._stop_session(timeout), self._loop)
             try:
-                future.result()
+                # Wait with timeout for clean shutdown
+                future.result(timeout=timeout)
+                logger.debug("SSE session stopped cleanly")
             except Exception as e:
-                logger.error(f"Streaming disconnect error: {e}")
+                logger.warning(f"Error during SSE disconnect: {e}")
+                # Force close the loop if clean shutdown failed
+                if self._loop and self._loop.is_running():
+                    try:
+                        self._loop.call_soon_threadsafe(self._loop.stop)
+                    except Exception:
+                        pass
 
         if self._sse_thread:
-            self._sse_thread.join(timeout=5)
+            self._sse_thread.join(timeout=timeout)
+            if self._sse_thread.is_alive():
+                logger.warning("SSE thread did not terminate gracefully within timeout")
+            else:
+                logger.debug("SSE thread terminated")
 
         logger.debug("Streaming session disconnected")
 
@@ -172,52 +188,84 @@ class SSEClient:
     async def _init_session(self):
         url = self._get_sse_url(self.api_host, self.client_key)
         
-        while self.is_running:
-            try:
-                async with aiohttp.ClientSession(headers=self.headers, 
-                    timeout=aiohttp.ClientTimeout(connect=self.timeout)) as session:
-                    self._sse_session = session
-
-                    async with session.get(url) as response:
-                        response.raise_for_status()
-                        await self._process_response(response)
-            except ClientResponseError as e:
-                logger.error(f"Streaming error, closing connection: {e.status} {e.message}")
-                self.is_running = False
-                break
-            except (ClientConnectorError, ClientPayloadError) as e:
-                logger.error(f"Streaming error: {e}")
-                if not self.is_running:
+        try:
+            while self.is_running:
+                try:
+                    async with aiohttp.ClientSession(headers=self.headers, 
+                        timeout=aiohttp.ClientTimeout(connect=self.timeout)) as session:
+                        self._sse_session = session
+
+                        async with session.get(url) as response:
+                            response.raise_for_status()
+                            await self._process_response(response)
+                except ClientResponseError as e:
+                    logger.error(f"Streaming error, closing connection: {e.status} {e.message}")
+                    self.is_running = False
+                    break
+                except (ClientConnectorError, ClientPayloadError) as e:
+                    logger.error(f"Streaming error: {e}")
+                    if not self.is_running:
+                        break
+                    await self._wait_for_reconnect()
+                except TimeoutError:
+                    logger.warning(f"Streaming connection timed out after {self.timeout} seconds.")
+                    if not self.is_running:
+                        break
+                    await self._wait_for_reconnect()
+                except asyncio.CancelledError:
+                    logger.debug("SSE session cancelled")
                     break
-                await self._wait_for_reconnect()
-            except TimeoutError:
-                logger.warning(f"Streaming connection timed out after {self.timeout} seconds.")
-                await self._wait_for_reconnect()
-            except asyncio.CancelledError:
-                logger.debug("Streaming was cancelled.")
-                break
-            finally:
-                await self._close_session()
+                finally:
+                    await self._close_session()
+        except asyncio.CancelledError:
+            logger.debug("SSE _init_session cancelled")
+            pass
+        finally:
+            # Ensure session is closed on any exit
+            await self._close_session()
 
     async def _process_response(self, response):
         event_data = {}
-        async for line in response.content:
-            decoded_line = line.decode('utf-8').strip()
-            if decoded_line.startswith("event:"):
-                event_data['type'] = decoded_line[len("event:"):].strip()
-            elif decoded_line.startswith("data:"):
-                event_data['data'] = event_data.get('data', '') + f"\n{decoded_line[len('data:'):].strip()}"
-            elif not decoded_line:
-                if 'type' in event_data and 'data' in event_data:
+        try:
+            async for line in response.content:
+                # Check for cancellation before processing each line
+                if not self.is_running:
+                    logger.debug("SSE processing stopped - is_running is False")
+                    break
+                    
+                decoded_line = line.decode('utf-8').strip()
+                if decoded_line.startswith("event:"):
+                    event_data['type'] = decoded_line[len("event:"):].strip()
+                elif decoded_line.startswith("data:"):
+                    event_data['data'] = event_data.get('data', '') + f"\n{decoded_line[len('data:'):].strip()}"
+                elif not decoded_line:
+                    if 'type' in event_data and 'data' in event_data:
+                        try:
+                            self.on_event(event_data)
+                        except Exception as e:
+                            logger.warning(f"Error in event handler: {e}")
+                    event_data = {}
+            
+            # Process any remaining event data
+            if 'type' in event_data and 'data' in event_data:
+                try:
                     self.on_event(event_data)
-                event_data = {}
-
-        if 'type' in event_data and 'data' in event_data:
-            self.on_event(event_data)
+                except Exception as e:
+                    logger.warning(f"Error in final event handler: {e}")
+        except asyncio.CancelledError:
+            logger.debug("SSE response processing cancelled")
+            raise
+        except Exception as e:
+            logger.warning(f"Error processing SSE response: {e}")
+            raise
 
     async def _wait_for_reconnect(self):
         logger.info(f"Attempting to reconnect streaming in {self.reconnect_delay} seconds")
-        await asyncio.sleep(self.reconnect_delay)
+        try:
+            await asyncio.sleep(self.reconnect_delay)
+        except asyncio.CancelledError:
+            logger.debug("Reconnect wait cancelled")
+            raise
 
     async def _close_session(self):
         if self._sse_session:
@@ -235,18 +283,44 @@ class SSEClient:
             self._loop.run_until_complete(self._loop.shutdown_asyncgens())
             self._loop.close()
 
-    async def _stop_session(self):
-        if self._sse_session:
-            await self._sse_session.close()
+    async def _stop_session(self, timeout=10):
+        """Stop the SSE session and cancel all tasks with timeout"""
+        logger.debug("Stopping SSE session")
+        
+        # Close the session first
+        if self._sse_session and not self._sse_session.closed:
+            try:
+                await self._sse_session.close()
+                logger.debug("SSE session closed")
+            except Exception as e:
+                logger.warning(f"Error closing SSE session: {e}")
 
+        # Cancel all tasks in this loop
         if self._loop and self._loop.is_running():
-            tasks = [task for task in asyncio.all_tasks(self._loop) if not task.done()]
-            for task in tasks:
-                task.cancel()
-                try:
-                    await task
-                except asyncio.CancelledError:
-                    pass
+            try:
+                # Get all tasks for this specific loop
+                tasks = [task for task in asyncio.all_tasks(self._loop) 
+                        if not task.done() and task is not asyncio.current_task(self._loop)]
+                
+                if tasks:
+                    logger.debug(f"Cancelling {len(tasks)} SSE tasks")
+                    # Cancel all tasks
+                    for task in tasks:
+                        task.cancel()
+                    
+                    # Wait for tasks to complete with timeout
+                    try:
+                        await asyncio.wait_for(
+                            asyncio.gather(*tasks, return_exceptions=True),
+                            timeout=timeout
+                        )
+                        logger.debug("All SSE tasks cancelled successfully")
+                    except asyncio.TimeoutError:
+                        logger.warning("Some SSE tasks did not cancel within timeout")
+                    except Exception as e:
+                        logger.warning(f"Error during task cancellation: {e}")
+            except Exception as e:
+                logger.warning(f"Error during SSE task cleanup: {e}")
 
 class FeatureRepository(object):
     def __init__(self) -> None:
@@ -254,6 +328,11 @@ class FeatureRepository(object):
         self.http: Optional[PoolManager] = None
         self.sse_client: Optional[SSEClient] = None
         self._feature_update_callbacks: List[Callable[[Dict], None]] = []
+        
+        # Background refresh support
+        self._refresh_thread: Optional[threading.Thread] = None
+        self._refresh_stop_event = threading.Event()
+        self._refresh_lock = threading.Lock()
 
     def set_cache(self, cache: AbstractFeatureCache) -> None:
         self.cache = cache
@@ -302,6 +381,7 @@ class FeatureRepository(object):
                 return res
         return cached
     
+    
     async def load_features_async(
         self, api_host: str, client_key: str, decryption_key: str = "", ttl: int = 600
     ) -> Optional[Dict]:
@@ -415,8 +495,57 @@ class FeatureRepository(object):
         self.sse_client = self.sse_client or SSEClient(api_host=api_host, client_key=client_key, on_event=cb, timeout=streaming_timeout)
         self.sse_client.connect()
 
-    def stopAutoRefresh(self):
-        self.sse_client.disconnect()
+    def stopAutoRefresh(self, timeout=10):
+        """Stop auto refresh with timeout"""
+        if self.sse_client:
+            self.sse_client.disconnect(timeout=timeout)
+            self.sse_client = None
+    
+    def start_background_refresh(self, api_host: str, client_key: str, decryption_key: str, ttl: int = 600, refresh_interval: int = 300) -> None:
+        """Start periodic background refresh task"""
+        with self._refresh_lock:
+            if self._refresh_thread is not None:
+                return  # Already running
+            
+            self._refresh_stop_event.clear()
+            self._refresh_thread = threading.Thread(
+                target=self._background_refresh_worker,
+                args=(api_host, client_key, decryption_key, ttl, refresh_interval),
+                daemon=True
+            )
+            self._refresh_thread.start()
+            logger.debug("Started background refresh task")
+    
+    def _background_refresh_worker(self, api_host: str, client_key: str, decryption_key: str, ttl: int, refresh_interval: int) -> None:
+        """Worker method for periodic background refresh"""
+        while not self._refresh_stop_event.is_set():
+            try:
+                # Wait for the refresh interval or stop event
+                if self._refresh_stop_event.wait(refresh_interval):
+                    break  # Stop event was set
+                
+                logger.debug("Background refresh for Features - started")
+                res = self._fetch_features(api_host, client_key, decryption_key)
+                if res is not None:
+                    cache_key = api_host + "::" + client_key
+                    self.cache.set(cache_key, res, ttl)
+                    logger.debug("Background refresh completed")
+                    # Notify callbacks about fresh features
+                    self._notify_feature_update_callbacks(res)
+                else:
+                    logger.warning("Background refresh failed")
+            except Exception as e:
+                logger.warning(f"Background refresh error: {e}")
+    
+    def stop_background_refresh(self) -> None:
+        """Stop background refresh task"""
+        self._refresh_stop_event.set()
+        
+        with self._refresh_lock:
+            if self._refresh_thread is not None:
+                self._refresh_thread.join(timeout=1.0)  # Wait up to 1 second
+                self._refresh_thread = None
+                logger.debug("Stopped background refresh task")
 
     @staticmethod
     def _get_features_url(api_host: str, client_key: str) -> str:
@@ -446,6 +575,8 @@ class GrowthBook(object):
         savedGroups: dict = {},
         streaming: bool = False,
         streaming_connection_timeout: int = 30,
+        stale_while_revalidate: bool = False,
+        stale_ttl: int = 300,  # 5 minutes default
         plugins: List = None,
         # Deprecated args
         trackingCallback=None,
@@ -475,6 +606,8 @@ class GrowthBook(object):
 
         self._streaming = streaming
         self._streaming_timeout = streaming_connection_timeout
+        self._stale_while_revalidate = stale_while_revalidate
+        self._stale_ttl = stale_ttl
 
         # Deprecated args
         self._user = user
@@ -527,6 +660,13 @@ class GrowthBook(object):
         if self._streaming:
             self.load_features()
             self.startAutoRefresh()
+        elif self._stale_while_revalidate and self._client_key:
+            # Start background refresh task for stale-while-revalidate
+            self.load_features()  # Initial load
+            feature_repo.start_background_refresh(
+                self._api_host, self._client_key, self._decryption_key, 
+                self._cache_ttl, self._stale_ttl
+            )
 
     def _on_feature_update(self, features_data: Dict) -> None:
         """Callback to handle automatic feature updates from FeatureRepository"""
@@ -595,8 +735,15 @@ class GrowthBook(object):
             streaming_timeout=self._streaming_timeout
         )
 
-    def stopAutoRefresh(self):
-        feature_repo.stopAutoRefresh()
+    def stopAutoRefresh(self, timeout=10):
+        """Stop auto refresh with timeout"""
+        try:
+            if hasattr(feature_repo, 'sse_client') and feature_repo.sse_client:
+                feature_repo.sse_client.disconnect(timeout=timeout)
+            else:
+                feature_repo.stopAutoRefresh()
+        except Exception as e:
+            logger.warning(f"Error stopping auto refresh: {e}")
 
     # @deprecated, use set_features
     def setFeatures(self, features: dict) -> None:
@@ -639,23 +786,51 @@ class GrowthBook(object):
     def get_attributes(self) -> dict:
         return self._attributes
 
-    def destroy(self) -> None:
-        # Clean up plugins first
-        self._cleanup_plugins()
+    def destroy(self, timeout=10) -> None:
+        """Gracefully destroy the GrowthBook instance"""
+        logger.debug("Starting GrowthBook destroy process")
         
-        # Clean up feature update callback
-        if self._client_key:
-            feature_repo.remove_feature_update_callback(self._on_feature_update)
-            
-        self._subscriptions.clear()
-        self._tracked.clear()
-        self._assigned.clear()
-        self._trackingCallback = None
-        self._forcedVariations.clear()
-        self._overrides.clear()
-        self._groups.clear()
-        self._attributes.clear()
-        self._features.clear()
+        try:
+            # Clean up plugins
+            logger.debug("Cleaning up plugins")
+            self._cleanup_plugins()
+        except Exception as e:
+            logger.warning(f"Error cleaning up plugins: {e}")
+        
+        try:
+            logger.debug("Stopping auto refresh during destroy")
+            self.stopAutoRefresh(timeout=timeout)
+        except Exception as e:
+            logger.warning(f"Error stopping auto refresh during destroy: {e}")
+        
+        try:
+            # Stop background refresh operations
+            if self._stale_while_revalidate and self._client_key:
+                feature_repo.stop_background_refresh()
+        except Exception as e:
+            logger.warning(f"Error stopping background refresh during destroy: {e}")
+        
+        try:
+            # Clean up feature update callback
+            if self._client_key:
+                feature_repo.remove_feature_update_callback(self._on_feature_update)
+        except Exception as e:
+            logger.warning(f"Error removing feature update callback: {e}")
+        
+        # Clear all internal state
+        try:
+            self._subscriptions.clear()
+            self._tracked.clear()
+            self._assigned.clear()
+            self._trackingCallback = None
+            self._forcedVariations.clear()
+            self._overrides.clear()
+            self._groups.clear()
+            self._attributes.clear()
+            self._features.clear()
+            logger.debug("GrowthBook instance destroyed successfully")
+        except Exception as e:
+            logger.warning(f"Error clearing internal state: {e}")
 
     # @deprecated, use is_on
     def isOn(self, key: str) -> bool:
@@ -686,8 +861,8 @@ class GrowthBook(object):
     def _ensure_fresh_features(self) -> None:
         """Lazy refresh: Check cache expiry and refresh if needed, but only if client_key is provided"""
         
-        if self._streaming or not self._client_key:
-            return  # Skip cache checks - SSE handles freshness for streaming users
+        if self._streaming or self._stale_while_revalidate or not self._client_key:
+            return  # Skip cache checks - SSE or background refresh handles freshness
 
         try:
             self.load_features()

{growthbook-1.4.2 → growthbook-1.4.4/growthbook.egg-info}/PKG-INFO

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

{growthbook-1.4.2 → growthbook-1.4.4}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.4.2
+current_version = 1.4.4
 commit = True
 tag = True
 

{growthbook-1.4.2 → growthbook-1.4.4}/tests/test_growthbook.py

@@ -1009,4 +1009,164 @@ def test_multiple_instances_get_updated_on_cache_expiry(mocker):
     finally:
         gb1.destroy()
         gb2.destroy()
+        feature_repo.clear_cache()
+
+
+def test_stale_while_revalidate_basic_functionality(mocker):
+    """Test basic stale-while-revalidate functionality"""
+    # Mock responses - first call returns v1, subsequent calls return v2
+    mock_responses = [
+        {"features": {"test_feature": {"defaultValue": "v1"}}, "savedGroups": {}},
+        {"features": {"test_feature": {"defaultValue": "v2"}}, "savedGroups": {}}
+    ]
+    
+    call_count = 0
+    def mock_fetch_features(api_host, client_key, decryption_key=""):
+        nonlocal call_count
+        response = mock_responses[min(call_count, len(mock_responses) - 1)]
+        call_count += 1
+        return response
+    
+    # Clear cache and mock the fetch method
+    feature_repo.clear_cache()
+    m = mocker.patch.object(feature_repo, '_fetch_features', side_effect=mock_fetch_features)
+    
+    # Create GrowthBook instance with stale-while-revalidate enabled and short refresh interval
+    gb = GrowthBook(
+        api_host="https://cdn.growthbook.io",
+        client_key="test-key",
+        cache_ttl=10,  # 10 second TTL
+        stale_while_revalidate=True,
+        stale_ttl=1  # 1 second refresh interval for testing
+    )
+    
+    try:
+        # Initial evaluation - should use initial loaded data
+        assert gb.get_feature_value('test_feature', 'default') == "v1"
+        assert call_count == 1  # Initial load
+        
+        # Wait for background refresh to happen
+        import time as time_module
+        time_module.sleep(1.5)  # Wait longer than refresh interval
+        
+        # Should have triggered background refresh
+        assert call_count >= 2
+        
+        # Next evaluation should get updated data from background refresh
+        assert gb.get_feature_value('test_feature', 'default') == "v2"
+        
+    finally:
+        gb.destroy()
+        feature_repo.clear_cache()
+
+
+def test_stale_while_revalidate_starts_background_task(mocker):
+    """Test that stale-while-revalidate starts background refresh task"""
+    mock_response = {"features": {"test_feature": {"defaultValue": "fresh"}}, "savedGroups": {}}
+    
+    call_count = 0
+    def mock_fetch_features(api_host, client_key, decryption_key=""):
+        nonlocal call_count
+        call_count += 1
+        return mock_response
+    
+    # Clear cache and mock the fetch method
+    feature_repo.clear_cache()
+    m = mocker.patch.object(feature_repo, '_fetch_features', side_effect=mock_fetch_features)
+    
+    # Create GrowthBook instance with stale-while-revalidate enabled
+    gb = GrowthBook(
+        api_host="https://cdn.growthbook.io",
+        client_key="test-key",
+        stale_while_revalidate=True,
+        stale_ttl=5
+    )
+    
+    try:
+        # Should have started background refresh task
+        assert feature_repo._refresh_thread is not None
+        assert feature_repo._refresh_thread.is_alive()
+        
+        # Initial evaluation should work
+        assert gb.get_feature_value('test_feature', 'default') == "fresh"
+        assert call_count == 1  # Initial load
+        
+    finally:
+        gb.destroy()
+        feature_repo.clear_cache()
+
+def test_stale_while_revalidate_disabled_fallback(mocker):
+    """Test that when stale_while_revalidate is disabled, it falls back to normal behavior"""
+    mock_response = {"features": {"test_feature": {"defaultValue": "normal"}}, "savedGroups": {}}
+    
+    call_count = 0
+    def mock_fetch_features(api_host, client_key, decryption_key=""):
+        nonlocal call_count
+        call_count += 1
+        return mock_response
+    
+    # Clear cache and mock the fetch method
+    feature_repo.clear_cache()
+    m = mocker.patch.object(feature_repo, '_fetch_features', side_effect=mock_fetch_features)
+    
+    # Create GrowthBook instance with stale-while-revalidate disabled (default)
+    gb = GrowthBook(
+        api_host="https://cdn.growthbook.io",
+        client_key="test-key",
+        cache_ttl=1,  # Short TTL
+        stale_while_revalidate=False  # Explicitly disabled
+    )
+    
+    try:
+        # Should NOT have started background refresh task
+        assert feature_repo._refresh_thread is None
+        
+        # Initial evaluation
+        assert gb.get_feature_value('test_feature', 'default') == "normal"
+        assert call_count == 1
+        
+        # Manually expire the cache
+        cache_key = "https://cdn.growthbook.io::test-key"
+        if hasattr(feature_repo.cache, 'cache') and cache_key in feature_repo.cache.cache:
+            feature_repo.cache.cache[cache_key].expires = time() - 10
+        
+        # Next evaluation should fetch synchronously (normal behavior)
+        assert gb.get_feature_value('test_feature', 'default') == "normal"
+        assert call_count == 2  # Should have fetched again
+        
+    finally:
+        gb.destroy()
+        feature_repo.clear_cache()
+
+
+def test_stale_while_revalidate_cleanup(mocker):
+    """Test that background refresh is properly cleaned up"""
+    mock_response = {"features": {"test_feature": {"defaultValue": "test"}}, "savedGroups": {}}
+    
+    # Mock the fetch method
+    feature_repo.clear_cache()
+    m = mocker.patch.object(feature_repo, '_fetch_features', return_value=mock_response)
+    
+    # Create GrowthBook instance with stale-while-revalidate enabled
+    gb = GrowthBook(
+        api_host="https://cdn.growthbook.io",
+        client_key="test-key",
+        stale_while_revalidate=True
+    )
+    
+    try:
+        # Should have started background refresh task
+        assert feature_repo._refresh_thread is not None
+        assert feature_repo._refresh_thread.is_alive()
+        
+        # Destroy should clean up the background task
+        gb.destroy()
+        
+        # Background task should be stopped
+        assert feature_repo._refresh_thread is None or not feature_repo._refresh_thread.is_alive()
+        
+    finally:
+        # Ensure cleanup even if test fails
+        if feature_repo._refresh_thread:
+            feature_repo.stop_background_refresh()
         feature_repo.clear_cache()