growthbook 1.4.7__tar.gz → 1.4.9__tar.gz

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

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

{growthbook-1.4.7 → growthbook-1.4.9}/growthbook/__init__.py

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

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

@@ -139,6 +139,7 @@ class SSEClient:
         self.headers = {
             "Accept": "application/json; q=0.5, text/event-stream",
             "Cache-Control": "no-cache",
+            "Accept-Encoding": "gzip, deflate, br",
         }
 
         if headers:
@@ -323,6 +324,10 @@ class SSEClient:
             except Exception as e:
                 logger.warning(f"Error during SSE task cleanup: {e}")
 
+from collections import OrderedDict
+
+# ... (imports)
+
 class FeatureRepository(object):
     def __init__(self) -> None:
         self.cache: AbstractFeatureCache = InMemoryFeatureCache()
@@ -334,6 +339,12 @@ class FeatureRepository(object):
         self._refresh_thread: Optional[threading.Thread] = None
         self._refresh_stop_event = threading.Event()
         self._refresh_lock = threading.Lock()
+        
+        # ETag cache for bandwidth optimization
+        # Using OrderedDict for LRU cache (max 100 entries)
+        self._etag_cache: OrderedDict[str, Tuple[str, Dict[str, Any]]] = OrderedDict()
+        self._max_etag_entries = 100
+        self._etag_lock = threading.Lock()
 
     def set_cache(self, cache: AbstractFeatureCache) -> None:
         self.cache = cache
@@ -400,33 +411,125 @@ class FeatureRepository(object):
         return cached
 
     # Perform the GET request (separate method for easy mocking)
-    def _get(self, url: str):
+    def _get(self, url: str, headers: Optional[Dict[str, str]] = None):
         self.http = self.http or PoolManager()
-        return self.http.request("GET", url)
-    
+        return self.http.request("GET", url, headers=headers or {})
+
     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"
+        
+        # Check if we have a cached ETag for this URL
+        cached_etag = None
+        cached_data = None
+        with self._etag_lock:
+            if url in self._etag_cache:
+                # Move to end (mark as recently used)
+                self._etag_cache.move_to_end(url)
+                cached_etag, cached_data = self._etag_cache[url]
+                headers['If-None-Match'] = cached_etag
+                logger.debug(f"Using cached ETag for request: {cached_etag[:20]}...")
+            else:
+                logger.debug(f"No ETag cache found for URL: {url}")
+        
         try:
-            r = self._get(self._get_features_url(api_host, client_key))
+            r = self._get(url, headers)
+            
+            # Handle 304 Not Modified - content hasn't changed
+            if r.status == 304:
+                logger.debug(f"ETag match! Server returned 304 Not Modified - using cached data (saved bandwidth)")
+                if cached_data is not None:
+                    logger.debug(f"Returning cached response ({len(str(cached_data))} bytes)")
+                    return cached_data
+                else:
+                    logger.warning("Received 304 but no cached data available")
+                    return None
+            
             if r.status >= 400:
                 logger.warning(
                     "Failed to fetch features, received status code %d", r.status
                 )
                 return None
+            
             decoded = json.loads(r.data.decode("utf-8"))
+            
+            # Store the new ETag if present
+            response_etag = r.headers.get('ETag')
+            if response_etag:
+                with self._etag_lock:
+                    self._etag_cache[url] = (response_etag, decoded)
+                    # Enforce max size
+                    if len(self._etag_cache) > self._max_etag_entries:
+                        self._etag_cache.popitem(last=False)
+                        
+                    if cached_etag:
+                        logger.debug(f"ETag updated: {cached_etag[:20]}... -> {response_etag[:20]}...")
+                    else:
+                        logger.debug(f"New ETag cached: {response_etag[:20]}... ({len(str(decoded))} bytes)")
+                    logger.debug(f"ETag cache now contains {len(self._etag_cache)} entries")
+            else:
+                logger.debug("No ETag header in response")
+            
             return decoded  # type: ignore[no-any-return]
-        except Exception:
-            logger.warning("Failed to decode feature JSON from GrowthBook API")
+        except Exception as e:
+            logger.warning(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"
+        
+        # Check if we have a cached ETag for this URL
+        cached_etag = None
+        cached_data = None
+        with self._etag_lock:
+            if url in self._etag_cache:
+                # Move to end (mark as recently used)
+                self._etag_cache.move_to_end(url)
+                cached_etag, cached_data = self._etag_cache[url]
+                headers['If-None-Match'] = cached_etag
+                logger.debug(f"[Async] Using cached ETag for request: {cached_etag[:20]}...")
+            else:
+                logger.debug(f"[Async] No ETag cache found for URL: {url}")
+        
         try:
-            url = self._get_features_url(api_host, client_key)
             async with aiohttp.ClientSession() as session:
-                async with session.get(url) as response:
+                async with session.get(url, headers=headers) as response:
+                    # Handle 304 Not Modified - content hasn't changed
+                    if response.status == 304:
+                        logger.debug(f"[Async] ETag match! Server returned 304 Not Modified - using cached data (saved bandwidth)")
+                        if cached_data is not None:
+                            logger.debug(f"[Async] Returning cached response ({len(str(cached_data))} bytes)")
+                            return cached_data
+                        else:
+                            logger.warning("[Async] Received 304 but no cached data available")
+                            return None
+                    
                     if response.status >= 400:
                         logger.warning("Failed to fetch features, received status code %d", response.status)
                         return None
+                    
                     decoded = await response.json()
+                    
+                    # Store the new ETag if present
+                    response_etag = response.headers.get('ETag')
+                    if response_etag:
+                        with self._etag_lock:
+                            self._etag_cache[url] = (response_etag, decoded)
+                            # Enforce max size
+                            if len(self._etag_cache) > self._max_etag_entries:
+                                self._etag_cache.popitem(last=False)
+                                
+                            if cached_etag:
+                                logger.debug(f"[Async] ETag updated: {cached_etag[:20]}... -> {response_etag[:20]}...")
+                            else:
+                                logger.debug(f"[Async] New ETag cached: {response_etag[:20]}... ({len(str(decoded))} bytes)")
+                            logger.debug(f"[Async] ETag cache now contains {len(self._etag_cache)} entries")
+                    else:
+                        logger.debug("[Async] No ETag header in response")
+                    
                     return decoded  # type: ignore[no-any-return]
         except aiohttp.ClientError as e:
             logger.warning(f"HTTP request failed: {e}")

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

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

{growthbook-1.4.7 → growthbook-1.4.9}/growthbook.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ growthbook/plugins/base.py
 growthbook/plugins/growthbook_tracking.py
 growthbook/plugins/request_context.py
 tests/conftest.py
+tests/test_etag.py
 tests/test_growthbook.py
 tests/test_growthbook_client.py
 tests/test_plugins.py

{growthbook-1.4.7 → growthbook-1.4.9}/setup.cfg

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

growthbook-1.4.9/tests/test_etag.py

@@ -0,0 +1,345 @@
+"""
+Tests for ETag caching functionality in GrowthBook SDK.
+
+This test suite verifies that the SDK correctly implements ETag-based
+HTTP caching to reduce bandwidth and CDN load.
+"""
+import json
+import pytest
+from unittest.mock import Mock, patch, MagicMock
+from growthbook.growthbook import feature_repo, FeatureRepository
+
+
+class MockResponse:
+    """Mock HTTP response for testing"""
+    def __init__(self, status, data, headers=None):
+        self.status = status
+        self.data = data.encode('utf-8') if isinstance(data, str) else data
+        self.headers = headers or {}
+
+
+class MockAsyncResponse:
+    """Mock async HTTP response for testing"""
+    def __init__(self, status, data, headers=None):
+        self.status = status
+        self._data = data
+        self.headers = headers or {}
+    
+    async def json(self):
+        return json.loads(self._data) if isinstance(self._data, str) else self._data
+    
+    def __aenter__(self):
+        async def _aenter():
+            return self
+        return _aenter()
+    
+    def __aexit__(self, exc_type, exc_val, exc_tb):
+        async def _aexit():
+            pass
+        return _aexit()
+
+
+@pytest.fixture(autouse=True)
+def cleanup_etag_cache():
+    """Clear ETag cache before each test"""
+    feature_repo._etag_cache.clear()
+    yield
+    feature_repo._etag_cache.clear()
+
+
+class TestETags:
+    """Test ETag caching functionality"""
+    
+    def test_etag_initial_request_no_cache(self):
+        """First request should not send If-None-Match header"""
+        features_response = json.dumps({
+            "features": {"feature1": {"defaultValue": True}}
+        })
+        
+        with patch.object(feature_repo, '_get') as mock_get:
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=features_response,
+                headers={'ETag': '"abc123"'}
+            )
+            
+            result = feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            
+            # Verify request was made without If-None-Match
+            assert mock_get.called
+            call_args = mock_get.call_args
+            headers = call_args[1].get('headers', {})
+            assert 'If-None-Match' not in headers
+            
+            # Verify response was returned
+            assert result is not None
+            assert "features" in result
+            
+            # Verify ETag was cached
+            url = feature_repo._get_features_url("https://cdn.growthbook.io", "test_key")
+            assert url in feature_repo._etag_cache
+            cached_etag, cached_data = feature_repo._etag_cache[url]
+            assert cached_etag == '"abc123"'
+            assert cached_data == result
+    
+    def test_etag_second_request_sends_if_none_match(self):
+        """Second request should send If-None-Match header with cached ETag"""
+        features_response = json.dumps({
+            "features": {"feature1": {"defaultValue": True}}
+        })
+        
+        with patch.object(feature_repo, '_get') as mock_get:
+            # First request - returns 200 with ETag
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=features_response,
+                headers={'ETag': '"abc123"'}
+            )
+            
+            feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            
+            # Second request - should send If-None-Match
+            mock_get.reset_mock()
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=features_response,
+                headers={'ETag': '"abc123"'}
+            )
+            
+            feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            
+            # Verify If-None-Match was sent
+            call_args = mock_get.call_args
+            # Headers are passed as positional or keyword argument
+            if len(call_args[0]) > 1:
+                headers = call_args[0][1] if isinstance(call_args[0][1], dict) else {}
+            else:
+                headers = call_args[1].get('headers', {})
+            assert 'If-None-Match' in headers
+            assert headers['If-None-Match'] == '"abc123"'
+    
+    def test_etag_304_returns_cached_data(self):
+        """Server returning 304 should return cached data"""
+        features_response = json.dumps({
+            "features": {"feature1": {"defaultValue": True}}
+        })
+        
+        with patch.object(feature_repo, '_get') as mock_get:
+            # First request - returns 200 with ETag
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=features_response,
+                headers={'ETag': '"abc123"'}
+            )
+            
+            first_result = feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            
+            # Second request - returns 304 Not Modified
+            mock_get.return_value = MockResponse(
+                status=304,
+                data="",  # 304 responses have no body
+                headers={'ETag': '"abc123"'}
+            )
+            
+            second_result = feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            
+            # Verify cached data was returned
+            assert second_result is not None
+            assert second_result == first_result
+            assert "features" in second_result
+    
+    def test_etag_updated_on_content_change(self):
+        """ETag should be updated when content changes"""
+        with patch.object(feature_repo, '_get') as mock_get:
+            # First request - initial ETag
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=json.dumps({"features": {"feature1": {"defaultValue": True}}}),
+                headers={'ETag': '"abc123"'}
+            )
+            
+            feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            
+            url = feature_repo._get_features_url("https://cdn.growthbook.io", "test_key")
+            assert feature_repo._etag_cache[url][0] == '"abc123"'
+            
+            # Second request - new ETag (content changed)
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=json.dumps({"features": {"feature2": {"defaultValue": False}}}),
+                headers={'ETag': '"xyz789"'}
+            )
+            
+            result = feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            
+            # Verify ETag was updated
+            assert feature_repo._etag_cache[url][0] == '"xyz789"'
+            assert "feature2" in result["features"]
+    
+    def test_etag_no_header_still_works(self):
+        """Requests should work even if server doesn't send ETag"""
+        features_response = json.dumps({
+            "features": {"feature1": {"defaultValue": True}}
+        })
+        
+        with patch.object(feature_repo, '_get') as mock_get:
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=features_response,
+                headers={}  # No ETag header
+            )
+            
+            result = feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            
+            # Should still return data
+            assert result is not None
+            assert "features" in result
+            
+            # But ETag should not be cached
+            url = feature_repo._get_features_url("https://cdn.growthbook.io", "test_key")
+            assert url not in feature_repo._etag_cache
+    
+    def test_etag_multiple_urls_cached_separately(self):
+        """Different URLs should have separate ETag cache entries"""
+        with patch.object(feature_repo, '_get') as mock_get:
+            # Request for key1
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=json.dumps({"features": {"feature1": {"defaultValue": True}}}),
+                headers={'ETag': '"etag-key1"'}
+            )
+            
+            feature_repo._fetch_and_decode("https://cdn.growthbook.io", "key1")
+            
+            # Request for key2
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=json.dumps({"features": {"feature2": {"defaultValue": False}}}),
+                headers={'ETag': '"etag-key2"'}
+            )
+            
+            feature_repo._fetch_and_decode("https://cdn.growthbook.io", "key2")
+            
+            # Verify both are cached with different ETags
+            url1 = feature_repo._get_features_url("https://cdn.growthbook.io", "key1")
+            url2 = feature_repo._get_features_url("https://cdn.growthbook.io", "key2")
+            
+            assert url1 in feature_repo._etag_cache
+            assert url2 in feature_repo._etag_cache
+            assert feature_repo._etag_cache[url1][0] == '"etag-key1"'
+            assert feature_repo._etag_cache[url2][0] == '"etag-key2"'
+    
+    def test_etag_bandwidth_savings(self):
+        """Test that 304 responses save bandwidth compared to full responses"""
+        large_features = {
+            "features": {f"feature{i}": {"defaultValue": True} for i in range(100)}
+        }
+        features_response = json.dumps(large_features)
+        
+        with patch.object(feature_repo, '_get') as mock_get:
+            # First request - full response
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=features_response,
+                headers={'ETag': '"large-response"'}
+            )
+            
+            first_result = feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            first_size = len(features_response)
+            
+            # Second request - 304 response (minimal data)
+            mock_get.return_value = MockResponse(
+                status=304,
+                data="",  # No body in 304
+                headers={'ETag': '"large-response"'}
+            )
+            
+            second_result = feature_repo._fetch_and_decode("https://cdn.growthbook.io", "test_key")
+            second_size = 0  # 304 has no body
+            
+            # Verify we got the same data
+            assert first_result == second_result
+            
+            # Verify bandwidth savings
+            assert first_size > 1000  # Large response
+            assert second_size == 0  # 304 response has no body
+            print(f"\n💾 Bandwidth saved: {first_size} bytes (100% savings on cache hit)")
+    
+    def test_etag_cache_persistence_across_requests(self):
+        """Test that ETag cache persists across multiple different requests"""
+        with patch.object(feature_repo, '_get') as mock_get:
+            # Make 3 requests to different keys
+            for i in range(3):
+                mock_get.return_value = MockResponse(
+                    status=200,
+                    data=json.dumps({"features": {f"feature{i}": {}}}),
+                    headers={'ETag': f'"etag-{i}"'}
+                )
+                feature_repo._fetch_and_decode("https://cdn.growthbook.io", f"key{i}")
+            
+            # Verify all 3 ETags are cached
+            assert len(feature_repo._etag_cache) == 3
+            
+            # Verify each ETag is correct
+            for i in range(3):
+                url = feature_repo._get_features_url("https://cdn.growthbook.io", f"key{i}")
+                assert url in feature_repo._etag_cache
+                assert feature_repo._etag_cache[url][0] == f'"etag-{i}"'
+    
+    def test_etag_cache_initialized(self):
+        """ETag cache should be initialized on FeatureRepository instantiation"""
+        assert hasattr(feature_repo, '_etag_cache')
+        assert isinstance(feature_repo._etag_cache, dict)
+
+    def test_etag_cache_lru_eviction(self):
+        """Test that ETag cache enforces size limit and LRU eviction"""
+        # Set a small limit for testing
+        feature_repo._max_etag_entries = 3
+        
+        with patch.object(feature_repo, '_get') as mock_get:
+            # Fill cache to limit
+            for i in range(3):
+                mock_get.return_value = MockResponse(
+                    status=200,
+                    data=json.dumps({"features": {f"feature{i}": {}}}),
+                    headers={'ETag': f'"etag-{i}"'}
+                )
+                feature_repo._fetch_and_decode("https://cdn.growthbook.io", f"key{i}")
+            
+            assert len(feature_repo._etag_cache) == 3
+            assert "https://cdn.growthbook.io/api/features/key0" in feature_repo._etag_cache
+            
+            # Add one more item - should evict key0 (least recently used)
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=json.dumps({"features": {"feature3": {}}}),
+                headers={'ETag': '"etag-3"'}
+            )
+            feature_repo._fetch_and_decode("https://cdn.growthbook.io", "key3")
+            
+            assert len(feature_repo._etag_cache) == 3
+            assert "https://cdn.growthbook.io/api/features/key0" not in feature_repo._etag_cache
+            assert "https://cdn.growthbook.io/api/features/key3" in feature_repo._etag_cache
+            
+            # Access key1 to make it most recently used
+            mock_get.return_value = MockResponse(
+                status=304,
+                data="",
+                headers={'ETag': '"etag-1"'}
+            )
+            feature_repo._fetch_and_decode("https://cdn.growthbook.io", "key1")
+            
+            # Add another item - should evict key2 (now least recently used)
+            mock_get.return_value = MockResponse(
+                status=200,
+                data=json.dumps({"features": {"feature4": {}}}),
+                headers={'ETag': '"etag-4"'}
+            )
+            feature_repo._fetch_and_decode("https://cdn.growthbook.io", "key4")
+            
+            assert len(feature_repo._etag_cache) == 3
+            assert "https://cdn.growthbook.io/api/features/key2" not in feature_repo._etag_cache
+            assert "https://cdn.growthbook.io/api/features/key1" in feature_repo._etag_cache  # Preserved!
+    
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

{growthbook-1.4.7 → growthbook-1.4.9}/tests/test_growthbook.py

@@ -799,6 +799,7 @@ class MockHttpResp:
     def __init__(self, status: int, data: str) -> None:
         self.status = status
         self.data = data.encode("utf-8")
+        self.headers = {}  # Add headers attribute for ETag support
 
 
 def test_feature_repository(mocker):
@@ -807,7 +808,10 @@ def test_feature_repository(mocker):
     m.return_value = MockHttpResp(200, json.dumps(expected))
     features = feature_repo.load_features("https://cdn.growthbook.io", "sdk-abc123")
 
-    m.assert_called_once_with("https://cdn.growthbook.io/api/features/sdk-abc123")
+    # Updated assertion to account for headers parameter
+    assert m.call_count == 1
+    call_args = m.call_args[0]
+    assert call_args[0] == "https://cdn.growthbook.io/api/features/sdk-abc123"
     assert features == expected
 
     # Uses in-memory cache for the 2nd call
@@ -831,7 +835,10 @@ def test_feature_repository_error(mocker):
     m.return_value = MockHttpResp(400, "400 Error")
     features = feature_repo.load_features("https://cdn.growthbook.io", "sdk-abc123")
 
-    m.assert_called_once_with("https://cdn.growthbook.io/api/features/sdk-abc123")
+    # Updated assertion to account for headers parameter
+    assert m.call_count == 1
+    call_args = m.call_args[0]
+    assert call_args[0] == "https://cdn.growthbook.io/api/features/sdk-abc123"
     assert features is None
 
     # Does not cache errors
@@ -863,7 +870,10 @@ def test_feature_repository_encrypted(mocker):
         "https://cdn.growthbook.io", "sdk-abc123", "Zvwv/+uhpFDznZ6SX28Yjg=="
     )
 
-    m.assert_called_once_with("https://cdn.growthbook.io/api/features/sdk-abc123")
+    # Updated assertion to account for headers parameter
+    assert m.call_count == 1
+    call_args = m.call_args[0]
+    assert call_args[0] == "https://cdn.growthbook.io/api/features/sdk-abc123"
     assert features == {"features": {"feature": {"defaultValue": True}}}
 
     feature_repo.clear_cache()
@@ -884,7 +894,10 @@ def test_load_features(mocker):
     assert m.call_count == 0
 
     gb.load_features()
-    m.assert_called_once_with("https://cdn.growthbook.io/api/features/sdk-abc123")
+    # Updated assertion to account for headers parameter
+    assert m.call_count == 1
+    call_args = m.call_args[0]
+    assert call_args[0] == "https://cdn.growthbook.io/api/features/sdk-abc123"
 
     assert gb.get_features()["feature"].to_dict() == {"defaultValue": 5, "rules": []}
 
@@ -944,7 +957,10 @@ def test_loose_unmarshalling(mocker):
     assert m.call_count == 0
 
     gb.load_features()
-    m.assert_called_once_with("https://cdn.growthbook.io/api/features/sdk-abc123")
+    # Updated assertion to account for headers parameter
+    assert m.call_count == 1
+    call_args = m.call_args[0]
+    assert call_args[0] == "https://cdn.growthbook.io/api/features/sdk-abc123"
 
     assert gb.get_features()["feature"].to_dict() == {
         "defaultValue": 5,