growthbook 1.4.5__tar.gz → 1.4.7__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.4.5
+Version: 1.4.7
 Summary: Powerful Feature flagging and A/B testing for Python apps
 Home-page: https://github.com/growthbook/growthbook-python
 Author: GrowthBook
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -56,6 +57,24 @@ Powerful Feature flagging and A/B testing for Python apps.
 
 `pip install growthbook` (recommended) or copy `growthbook.py` into your project
 
+## Type Checking Support
+
+The GrowthBook Python SDK is fully typed and includes inline type hints for all public APIs. This enables:
+
+- **Better IDE support** with autocomplete and inline documentation
+- **Type safety** - catch bugs at development time with mypy or other type checkers
+- **Better code documentation** - types serve as inline documentation
+- **Safer refactoring** - type checkers will catch breaking changes
+
+To use type checking with mypy:
+
+```bash
+pip install mypy
+mypy your_code.py
+```
+
+The SDK includes a `py.typed` marker file and is compliant with [PEP 561](https://www.python.org/dev/peps/pep-0561/).
+
 ## Quick Usage
 
 ```python
@@ -499,7 +518,6 @@ class MyStickyBucketService(AbstractStickyBucketService):
         })
 
 # Pass in an instance of this service to your GrowthBook constructor
-
 gb = GrowthBook(
   sticky_bucket_service = MyStickyBucketService()
 )

{growthbook-1.4.5 → growthbook-1.4.7}/README.md

@@ -21,6 +21,24 @@ Powerful Feature flagging and A/B testing for Python apps.
 
 `pip install growthbook` (recommended) or copy `growthbook.py` into your project
 
+## Type Checking Support
+
+The GrowthBook Python SDK is fully typed and includes inline type hints for all public APIs. This enables:
+
+- **Better IDE support** with autocomplete and inline documentation
+- **Type safety** - catch bugs at development time with mypy or other type checkers
+- **Better code documentation** - types serve as inline documentation
+- **Safer refactoring** - type checkers will catch breaking changes
+
+To use type checking with mypy:
+
+```bash
+pip install mypy
+mypy your_code.py
+```
+
+The SDK includes a `py.typed` marker file and is compliant with [PEP 561](https://www.python.org/dev/peps/pep-0561/).
+
 ## Quick Usage
 
 ```python
@@ -464,7 +482,6 @@ class MyStickyBucketService(AbstractStickyBucketService):
         })
 
 # Pass in an instance of this service to your GrowthBook constructor
-
 gb = GrowthBook(
   sticky_bucket_service = MyStickyBucketService()
 )

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

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

{growthbook-1.4.5 → growthbook-1.4.7}/growthbook/common_types.py

@@ -29,30 +29,30 @@ class Experiment(object):
     def __init__(
         self,
         key: str,
-        variations: list,
-        weights: List[float] = None,
+        variations: List[Any],
+        weights: Optional[List[float]] = None,
         active: bool = True,
         status: str = "running",
-        coverage: int = None,
-        condition: dict = None,
-        namespace: Tuple[str, float, float] = None,
+        coverage: Optional[float] = None,
+        condition: Optional[Dict[str, Any]] = None,
+        namespace: Optional[Tuple[str, float, float]] = None,
         url: str = "",
-        include=None,
-        groups: list = None,
-        force: int = None,
+        include: Optional[Any] = None,
+        groups: Optional[List[Any]] = None,
+        force: Optional[int] = None,
         hashAttribute: str = "id",
-        fallbackAttribute: str = None,
-        hashVersion: int = None,
-        ranges: List[Tuple[float, float]] = None,
-        meta: List[VariationMeta] = None,
-        filters: List[Filter] = None,
-        seed: str = None,
-        name: str = None,
-        phase: str = None,
+        fallbackAttribute: Optional[str] = None,
+        hashVersion: Optional[int] = None,
+        ranges: Optional[List[Tuple[float, float]]] = None,
+        meta: Optional[List[VariationMeta]] = None,
+        filters: Optional[List[Filter]] = None,
+        seed: Optional[str] = None,
+        name: Optional[str] = None,
+        phase: Optional[str] = None,
         disableStickyBucketing: bool = False,
-        bucketVersion: int = None,
-        minBucketVersion: int = None,
-        parentConditions: List[dict] = None,
+        bucketVersion: Optional[int] = None,
+        minBucketVersion: Optional[int] = None,
+        parentConditions: Optional[List[Dict[str, Any]]] = None,
     ) -> None:
         self.key = key
         self.variations = variations
@@ -85,8 +85,8 @@ class Experiment(object):
         self.include = include
         self.groups = groups
 
-    def to_dict(self):
-        obj = {
+    def to_dict(self) -> Dict[str, Any]:
+        obj: Dict[str, Any] = {
             "key": self.key,
             "variations": self.variations,
             "weights": self.weights,
@@ -118,7 +118,7 @@ class Experiment(object):
 
         return obj
 
-    def update(self, data: dict) -> None:
+    def update(self, data: Dict[str, Any]) -> None:
         weights = data.get("weights", None)
         status = data.get("status", None)
         coverage = data.get("coverage", None)
@@ -145,13 +145,13 @@ class Result(object):
         self,
         variationId: int,
         inExperiment: bool,
-        value,
+        value: Any,
         hashUsed: bool,
         hashAttribute: str,
         hashValue: str,
         featureId: Optional[str],
-        meta: VariationMeta = None,
-        bucket: float = None,
+        meta: Optional[VariationMeta] = None,
+        bucket: Optional[float] = None,
         stickyBucketUsed: bool = False,
     ) -> None:
         self.variationId = variationId
@@ -176,8 +176,8 @@ class Result(object):
             if "passthrough" in meta:
                 self.passthrough = meta["passthrough"]
 
-    def to_dict(self) -> dict:
-        obj = {
+    def to_dict(self) -> Dict[str, Any]:
+        obj: Dict[str, Any] = {
             "featureId": self.featureId,
             "variationId": self.variationId,
             "inExperiment": self.inExperiment,
@@ -201,11 +201,11 @@ class Result(object):
 class FeatureResult(object):
     def __init__(
         self,
-        value,
+        value: Any,
         source: str,
-        experiment: Experiment = None,
-        experimentResult: Result = None,
-        ruleId: str = None,
+        experiment: Optional[Experiment] = None,
+        experimentResult: Optional[Result] = None,
+        ruleId: Optional[str] = None,
     ) -> None:
         self.value = value
         self.source = source
@@ -215,8 +215,8 @@ class FeatureResult(object):
         self.on = bool(value)
         self.off = not bool(value)
 
-    def to_dict(self) -> dict:
-        data = {
+    def to_dict(self) -> Dict[str, Any]:
+        data: Dict[str, Any] = {
             "value": self.value,
             "source": self.source,
             "on": self.on,
@@ -231,7 +231,9 @@ class FeatureResult(object):
         return data
 
 class Feature(object):
-    def __init__(self, defaultValue=None, rules: list = []) -> None:
+    def __init__(self, defaultValue: Any = None, rules: Optional[List[Any]] = None) -> None:
+        if rules is None:
+            rules = []
         self.defaultValue = defaultValue
         self.rules: List[FeatureRule] = []
         for rule in rules:
@@ -263,7 +265,7 @@ class Feature(object):
                     parentConditions=rule.get("parentConditions", None),
                 ))
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> Dict[str, Any]:
         return {
             "defaultValue": self.defaultValue,
             "rules": [rule.to_dict() for rule in self.rules],
@@ -272,28 +274,28 @@ class Feature(object):
 class FeatureRule(object):
     def __init__(
         self,
-        id: str = None,
+        id: Optional[str] = None,
         key: str = "",
-        variations: list = None,
-        weights: List[float] = None,
-        coverage: int = None,
-        condition: dict = None,
-        namespace: Tuple[str, float, float] = None,
-        force=None,
+        variations: Optional[List[Any]] = None,
+        weights: Optional[List[float]] = None,
+        coverage: Optional[float] = None,
+        condition: Optional[Dict[str, Any]] = None,
+        namespace: Optional[Tuple[str, float, float]] = None,
+        force: Optional[Any] = None,
         hashAttribute: str = "id",
-        fallbackAttribute: str = None,
-        hashVersion: int = None,
-        range: Tuple[float, float] = None,
-        ranges: List[Tuple[float, float]] = None,
-        meta: List[VariationMeta] = None,
-        filters: List[Filter] = None,
-        seed: str = None,
-        name: str = None,
-        phase: str = None,
+        fallbackAttribute: Optional[str] = None,
+        hashVersion: Optional[int] = None,
+        range: Optional[Tuple[float, float]] = None,
+        ranges: Optional[List[Tuple[float, float]]] = None,
+        meta: Optional[List[VariationMeta]] = None,
+        filters: Optional[List[Filter]] = None,
+        seed: Optional[str] = None,
+        name: Optional[str] = None,
+        phase: Optional[str] = None,
         disableStickyBucketing: bool = False,
-        bucketVersion: int = None,
-        minBucketVersion: int = None,
-        parentConditions: List[dict] = None,
+        bucketVersion: Optional[int] = None,
+        minBucketVersion: Optional[int] = None,
+        parentConditions: Optional[List[Dict[str, Any]]] = None,
     ) -> None:
 
         if disableStickyBucketing:
@@ -322,7 +324,7 @@ class FeatureRule(object):
         self.minBucketVersion = minBucketVersion or 0
         self.parentConditions = parentConditions
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> Dict[str, Any]:
         data: Dict[str, Any] = {}
         if self.id:
             data["id"] = self.id
@@ -410,6 +412,7 @@ class UserContext:
     forced_variations: Dict[str, Any] = field(default_factory=dict)
     overrides: Dict[str, Any] = field(default_factory=dict)
     sticky_bucket_assignment_docs: Dict[str, Any] = field(default_factory=dict)
+    skip_all_experiments: bool = False
 
 @dataclass
 class Options:
@@ -426,7 +429,7 @@ class Options:
     sticky_bucket_service: Optional[AbstractStickyBucketService] = None
     sticky_bucket_identifier_attributes: Optional[List[str]] = None
     on_experiment_viewed: Optional[Callable[[Experiment, Result, Optional[UserContext]], None]] = None
-    on_feature_usage: Optional[Callable[[str, 'FeatureResult'], None]] = None
+    on_feature_usage: Optional[Callable[[str, 'FeatureResult', UserContext], None]] = None
     tracking_plugins: Optional[List[Any]] = None
 
 

{growthbook-1.4.5 → growthbook-1.4.7}/growthbook/core.py

@@ -9,7 +9,7 @@ from .common_types import EvaluationContext, FeatureResult, Experiment, Filter,
 
 logger = logging.getLogger("growthbook.core")
 
-def evalCondition(attributes: dict, condition: dict, savedGroups: dict = None) -> bool:
+def evalCondition(attributes: Dict[str, Any], condition: Dict[str, Any], savedGroups: Optional[Dict[str, Any]] = None) -> bool:
     for key, value in condition.items():
         if key == "$or":
             if not evalOr(attributes, value, savedGroups):
@@ -28,7 +28,7 @@ def evalCondition(attributes: dict, condition: dict, savedGroups: dict = None) -
 
     return True
 
-def evalOr(attributes, conditions, savedGroups) -> bool:
+def evalOr(attributes: Dict[str, Any], conditions: List[Any], savedGroups: Optional[Dict[str, Any]]) -> bool:
     if len(conditions) == 0:
         return True
 
@@ -38,13 +38,13 @@ def evalOr(attributes, conditions, savedGroups) -> bool:
     return False
 
 
-def evalAnd(attributes, conditions, savedGroups) -> bool:
+def evalAnd(attributes: Dict[str, Any], conditions: List[Any], savedGroups: Optional[Dict[str, Any]]) -> bool:
     for condition in conditions:
         if not evalCondition(attributes, condition, savedGroups):
             return False
     return True
 
-def isOperatorObject(obj) -> bool:
+def isOperatorObject(obj: Any) -> bool:
     for key in obj.keys():
         if key[0] != "$":
             return False
@@ -82,7 +82,7 @@ def evalConditionValue(conditionValue, attributeValue, savedGroups) -> bool:
             if not evalOperatorCondition(key, attributeValue, value, savedGroups):
                 return False
         return True
-    return conditionValue == attributeValue
+    return bool(conditionValue == attributeValue)
 
 def elemMatch(condition, attributeValue, savedGroups) -> bool:
     if not type(attributeValue) is list:
@@ -208,7 +208,7 @@ def evalOperatorCondition(operator, attributeValue, conditionValue, savedGroups)
             return attributeValue is None
         return attributeValue is not None
     elif operator == "$type":
-        return getType(attributeValue) == conditionValue
+        return bool(getType(attributeValue) == conditionValue)
     elif operator == "$not":
         return not evalConditionValue(conditionValue, attributeValue, savedGroups)
     return False
@@ -263,18 +263,18 @@ def _getOrigHashValue(
 
     return (actual_attr, val)
 
-def _getHashValue(eval_context: EvaluationContext, attr: str = None, fallbackAttr: str = None) -> Tuple[str, str]:
+def _getHashValue(eval_context: EvaluationContext, attr: Optional[str] = None, fallbackAttr: Optional[str] = None) -> Tuple[str, str]:
     (attr, val) = _getOrigHashValue(attr=attr, fallbackAttr=fallbackAttr, eval_context=eval_context)
     return (attr, str(val))
 
 def _isIncludedInRollout(
     seed: str,
     eval_context: EvaluationContext,
-    hashAttribute: str = None,
-    fallbackAttribute: str = None,
-    range: Tuple[float, float] = None,
-    coverage: float = None,
-    hashVersion: int = None
+    hashAttribute: Optional[str] = None,
+    fallbackAttribute: Optional[str] = None,
+    range: Optional[Tuple[float, float]] = None,
+    coverage: Optional[float] = None,
+    hashVersion: Optional[int] = None
 ) -> bool:
     if coverage is None and range is None:
         return True
@@ -388,7 +388,7 @@ def getEqualWeights(numVariations: int) -> List[float]:
 
 
 def getBucketRanges(
-    numVariations: int, coverage: float = 1, weights: List[float] = None
+    numVariations: int, coverage: float = 1, weights: Optional[List[float]] = None
 ) -> List[Tuple[float, float]]:
     if coverage < 0:
         coverage = 0
@@ -412,9 +412,9 @@ def getBucketRanges(
 
 def eval_feature(
     key: str,
-    evalContext: EvaluationContext = None,
-    callback_subscription: Callable[[Experiment, Result], None] = None,
-    tracking_cb: Callable[[Experiment, Result, UserContext], None] = None
+    evalContext: Optional[EvaluationContext] = None,
+    callback_subscription: Optional[Callable[[Experiment, Result], None]] = None,
+    tracking_cb: Optional[Callable[[Experiment, Result, UserContext], None]] = None
 ) -> FeatureResult:
     """Core feature evaluation logic as a standalone function"""
 
@@ -560,8 +560,8 @@ def _get_sticky_bucket_experiment_key(experiment_key: str, bucket_version: int =
     return experiment_key + "__" + str(bucket_version)
     
 def _get_sticky_bucket_assignments(evalContext: EvaluationContext,
-                                    attr: str = None,
-                                    fallback: str = None) -> Dict[str, str]:
+                                    attr: Optional[str] = None,
+                                    fallback: Optional[str] = None) -> Dict[str, str]:
     merged: Dict[str, str] = {}
 
     # Search for docs stored for attribute(id)
@@ -597,12 +597,12 @@ def _is_blocked(
 def _get_sticky_bucket_variation(
     experiment_key: str,
     evalContext: EvaluationContext,
-    bucket_version: int = None,
-    min_bucket_version: int = None,
-    meta: List[VariationMeta] = None,
-    hash_attribute: str = None,
-    fallback_attribute: str = None,
-) -> dict:
+    bucket_version: Optional[int] = None,
+    min_bucket_version: Optional[int] = None,
+    meta: Optional[List[VariationMeta]] = None,
+    hash_attribute: Optional[str] = None,
+    fallback_attribute: Optional[str] = None,
+) -> Dict[str, Any]:
     bucket_version = bucket_version or 0
     min_bucket_version = min_bucket_version or 0
     meta = meta or []
@@ -633,8 +633,8 @@ def _get_sticky_bucket_variation(
 
 def run_experiment(experiment: Experiment, 
                    featureId: Optional[str] = None, 
-                   evalContext: EvaluationContext = None, 
-                   tracking_cb: Callable[[Experiment, Result, UserContext], None] = None
+                   evalContext: Optional[EvaluationContext] = None, 
+                   tracking_cb: Optional[Callable[[Experiment, Result, UserContext], None]] = None
                 ) -> Result:
     if evalContext is None:
         raise ValueError("evalContext is required - run_experiment")
@@ -821,11 +821,16 @@ def run_experiment(experiment: Experiment,
             experiment=experiment, variationId=experiment.force, featureId=featureId, evalContext=evalContext
         )
 
-    # 12. Exclude if in QA mode
+    # 12. Exclude if in QA mode (global)
     if evalContext.global_ctx.options.qa_mode:
         logger.debug("Skip experiment %s because of QA Mode", experiment.key)
         return _getExperimentResult(experiment=experiment, featureId=featureId, evalContext=evalContext)
 
+    # 12.1. Exclude if user has skip_all_experiments flag set
+    if evalContext.user.skip_all_experiments:
+        logger.debug("Skip experiment %s because user has skip_all_experiments flag set", experiment.key)
+        return _getExperimentResult(experiment=experiment, featureId=featureId, evalContext=evalContext)
+
     # 12.5. If experiment is stopped, return immediately
     if experiment.status == "stopped":
         logger.debug("Skip experiment %s because it is stopped", experiment.key)
@@ -891,8 +896,8 @@ def _getExperimentResult(
     evalContext: EvaluationContext,
     variationId: int = -1,
     hashUsed: bool = False,
-    featureId: str = None,
-    bucket: float = None,
+    featureId: Optional[str] = None,
+    bucket: Optional[float] = None,
     stickyBucketUsed: bool = False
 ) -> Result:
     inExperiment = True

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

@@ -9,6 +9,7 @@ import sys
 import json
 import threading
 import logging
+import warnings
 
 from abc import ABC, abstractmethod
 from typing import Optional, Any, Set, Tuple, List, Dict, Callable
@@ -204,14 +205,14 @@ class SSEClient:
                     break
                 except (ClientConnectorError, ClientPayloadError) as e:
                     logger.error(f"Streaming error: {e}")
-                    if not self.is_running:
-                        break
                     await self._wait_for_reconnect()
+                    if not self.is_running:
+                        break  # type: ignore[unreachable]
                 except TimeoutError:
                     logger.warning(f"Streaming connection timed out after {self.timeout} seconds.")
-                    if not self.is_running:
-                        break
                     await self._wait_for_reconnect()
+                    if not self.is_running:
+                        break  # type: ignore[unreachable]
                 except asyncio.CancelledError:
                     logger.debug("SSE session cancelled")
                     break
@@ -412,7 +413,7 @@ class FeatureRepository(object):
                 )
                 return None
             decoded = json.loads(r.data.decode("utf-8"))
-            return decoded
+            return decoded  # type: ignore[no-any-return]
         except Exception:
             logger.warning("Failed to decode feature JSON from GrowthBook API")
             return None
@@ -426,7 +427,7 @@ class FeatureRepository(object):
                         logger.warning("Failed to fetch features, received status code %d", response.status)
                         return None
                     decoded = await response.json()
-                    return decoded
+                    return decoded  # type: ignore[no-any-return]
         except aiohttp.ClientError as e:
             logger.warning(f"HTTP request failed: {e}")
             return None
@@ -475,7 +476,7 @@ class FeatureRepository(object):
 
         data = self.decrypt_response(decoded, decryption_key)
 
-        return data
+        return data  # type: ignore[no-any-return]
         
     async def _fetch_features_async(
         self, api_host: str, client_key: str, decryption_key: str = ""
@@ -486,7 +487,7 @@ class FeatureRepository(object):
 
         data = self.decrypt_response(decoded, decryption_key)
 
-        return data
+        return data  # type: ignore[no-any-return]
 
 
     def startAutoRefresh(self, api_host, client_key, cb, streaming_timeout=30):
@@ -503,6 +504,10 @@ class FeatureRepository(object):
     
     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"""
+
+        if not client_key:
+            raise ValueError("Must specify `client_key` to refresh features")
+
         with self._refresh_lock:
             if self._refresh_thread is not None:
                 return  # Already running
@@ -570,15 +575,16 @@ class GrowthBook(object):
         client_key: str = "",
         decryption_key: str = "",
         cache_ttl: int = 600,
-        forced_variations: dict = {},
-        sticky_bucket_service: AbstractStickyBucketService = None,
-        sticky_bucket_identifier_attributes: List[str] = None,
-        savedGroups: dict = {},
+        forced_variations: Optional[Dict[str, Any]] = None,
+        sticky_bucket_service: Optional[AbstractStickyBucketService] = None,
+        sticky_bucket_identifier_attributes: Optional[List[str]] = None,
+        savedGroups: Optional[Dict[str, Any]] = None,
         streaming: bool = False,
         streaming_connection_timeout: int = 30,
         stale_while_revalidate: bool = False,
         stale_ttl: int = 300,  # 5 minutes default
-        plugins: List = None,
+        plugins: Optional[List[Any]] = None,
+        skip_all_experiments: bool = False,
         # Deprecated args
         trackingCallback=None,
         qaMode: bool = False,
@@ -591,7 +597,7 @@ class GrowthBook(object):
         self._attributes = attributes
         self._url = url
         self._features: Dict[str, Feature] = {}
-        self._saved_groups = savedGroups
+        self._saved_groups = savedGroups if savedGroups is not None else {}
         self._api_host = api_host
         self._client_key = client_key
         self._decryption_key = decryption_key
@@ -605,6 +611,7 @@ class GrowthBook(object):
         self._qaMode = qa_mode or qaMode
         self._trackingCallback = on_experiment_viewed or trackingCallback
         self._featureUsageCallback = on_feature_usage
+        self._skip_all_experiments = skip_all_experiments
 
         self._streaming = streaming
         self._streaming_timeout = streaming_connection_timeout
@@ -615,15 +622,16 @@ class GrowthBook(object):
         self._user = user
         self._groups = groups
         self._overrides = overrides
-        self._forcedVariations = forced_variations or forcedVariations
+        self._forcedVariations = (forced_variations if forced_variations is not None else forcedVariations) if forced_variations is not None or forcedVariations else {}
 
         self._tracked: Dict[str, Any] = {}
         self._assigned: Dict[str, Any] = {}
         self._subscriptions: Set[Any] = set()
+        self._is_updating_features = False
 
         # support plugins
-        self._plugins: List = plugins or []
-        self._initialized_plugins: List = []
+        self._plugins: List[Any] = plugins if plugins is not None else []
+        self._initialized_plugins: List[Any] = []
 
         self._global_ctx = GlobalContext(
             options=Options(
@@ -647,7 +655,8 @@ class GrowthBook(object):
             groups=self._groups,
             forced_variations=self._forcedVariations,
             overrides=self._overrides,
-            sticky_bucket_assignment_docs=self._sticky_bucket_assignment_docs
+            sticky_bucket_assignment_docs=self._sticky_bucket_assignment_docs,
+            skip_all_experiments=self._skip_all_experiments
         )
 
         if features:
@@ -662,7 +671,7 @@ class GrowthBook(object):
         if self._streaming:
             self.load_features()
             self.startAutoRefresh()
-        elif self._stale_while_revalidate and self._client_key:
+        elif self._stale_while_revalidate:
             # Start background refresh task for stale-while-revalidate
             self.load_features()  # Initial load
             feature_repo.start_background_refresh(
@@ -678,7 +687,6 @@ class GrowthBook(object):
             self._saved_groups = features_data["savedGroups"]
 
     def load_features(self) -> None:
-
         response = feature_repo.load_features(
             self._api_host, self._client_key, self._decryption_key, self._cache_ttl
         )
@@ -747,42 +755,47 @@ class GrowthBook(object):
         except Exception as e:
             logger.warning(f"Error stopping auto refresh: {e}")
 
-    # @deprecated, use set_features
     def setFeatures(self, features: dict) -> None:
+        warnings.warn("setFeatures is deprecated, use set_features instead", DeprecationWarning)
         return self.set_features(features)
 
     def set_features(self, features: dict) -> None:
-        self._features = {}
-        for key, feature in features.items():
-            if isinstance(feature, Feature):
-                self._features[key] = feature
-            else:
-                self._features[key] = Feature(
-                    rules=feature.get("rules", []),
-                    defaultValue=feature.get("defaultValue", None),
-                )
-        # Update the global context with the new features and saved groups
-        self._global_ctx.features = self._features
-        self._global_ctx.saved_groups = self._saved_groups
-        self.refresh_sticky_buckets()
+        # Prevent infinite recursion during feature updates
+        self._is_updating_features = True
+        try:
+            self._features = {}
+            for key, feature in features.items():
+                if isinstance(feature, Feature):
+                    self._features[key] = feature
+                else:
+                    self._features[key] = Feature(
+                        rules=feature.get("rules", []),
+                        defaultValue=feature.get("defaultValue", None),
+                    )
+            # Update the global context with the new features and saved groups
+            self._global_ctx.features = self._features
+            self._global_ctx.saved_groups = self._saved_groups
+            self.refresh_sticky_buckets()
+        finally:
+            self._is_updating_features = False
 
-    # @deprecated, use get_features
     def getFeatures(self) -> Dict[str, Feature]:
+        warnings.warn("getFeatures is deprecated, use get_features instead", DeprecationWarning)
         return self.get_features()
 
     def get_features(self) -> Dict[str, Feature]:
         return self._features
 
-    # @deprecated, use set_attributes
     def setAttributes(self, attributes: dict) -> None:
+        warnings.warn("setAttributes is deprecated, use set_attributes instead", DeprecationWarning)
         return self.set_attributes(attributes)
 
     def set_attributes(self, attributes: dict) -> None:
         self._attributes = attributes
         self.refresh_sticky_buckets()
 
-    # @deprecated, use get_attributes
     def getAttributes(self) -> dict:
+        warnings.warn("getAttributes is deprecated, use get_attributes instead", DeprecationWarning)
         return self.get_attributes()
 
     def get_attributes(self) -> dict:
@@ -835,35 +848,39 @@ class GrowthBook(object):
         except Exception as e:
             logger.warning(f"Error clearing internal state: {e}")
 
-    # @deprecated, use is_on
     def isOn(self, key: str) -> bool:
+        warnings.warn("isOn is deprecated, use is_on instead", DeprecationWarning)
         return self.is_on(key)
 
     def is_on(self, key: str) -> bool:
-        return self.evalFeature(key).on
+        return self.eval_feature(key).on
 
-    # @deprecated, use is_off
     def isOff(self, key: str) -> bool:
+        warnings.warn("isOff is deprecated, use is_off instead", DeprecationWarning)
         return self.is_off(key)
 
     def is_off(self, key: str) -> bool:
-        return self.evalFeature(key).off
+        return self.eval_feature(key).off
 
-    # @deprecated, use get_feature_value
     def getFeatureValue(self, key: str, fallback):
+        warnings.warn("getFeatureValue is deprecated, use get_feature_value instead", DeprecationWarning)
         return self.get_feature_value(key, fallback)
 
     def get_feature_value(self, key: str, fallback):
         res = self.eval_feature(key)
         return res.value if res.value is not None else fallback
 
-    # @deprecated, use eval_feature
     def evalFeature(self, key: str) -> FeatureResult:
+        warnings.warn("evalFeature is deprecated, use eval_feature instead", DeprecationWarning)
         return self.eval_feature(key)
     
     def _ensure_fresh_features(self) -> None:
         """Lazy refresh: Check cache expiry and refresh if needed, but only if client_key is provided"""
         
+        # Prevent infinite recursion when updating features (e.g., during sticky bucket refresh)
+        if self._is_updating_features:
+            return
+        
         if self._streaming or self._stale_while_revalidate or not self._client_key:
             return  # Skip cache checks - SSE or background refresh handles freshness
 
@@ -897,37 +914,35 @@ class GrowthBook(object):
         # Call feature usage callback if provided
         if self._featureUsageCallback:
             try:
-                self._featureUsageCallback(key, result)
+                self._featureUsageCallback(key, result, self._user_ctx)
             except Exception:
                 pass
         return result
 
-    # @deprecated, use get_all_results
     def getAllResults(self):
+        warnings.warn("getAllResults is deprecated, use get_all_results instead", DeprecationWarning)
         return self.get_all_results()
 
     def get_all_results(self):
         return self._assigned.copy()
 
     def _fireSubscriptions(self, experiment: Experiment, result: Result):
-        if experiment is None:
-            return
-        
-        prev = self._assigned.get(experiment.key, None)
-        if (
-            not prev
-            or prev["result"].inExperiment != result.inExperiment
-            or prev["result"].variationId != result.variationId
-        ):
-            self._assigned[experiment.key] = {
-                "experiment": experiment,
-                "result": result,
-            }
-            for cb in self._subscriptions:
-                try:
-                    cb(experiment, result)
-                except Exception:
-                    pass
+        if experiment is not None:
+            prev = self._assigned.get(experiment.key, None)
+            if (
+                not prev
+                or prev["result"].inExperiment != result.inExperiment
+                or prev["result"].variationId != result.variationId
+            ):
+                self._assigned[experiment.key] = {
+                    "experiment": experiment,
+                    "result": result,
+                }
+                for cb in self._subscriptions:
+                    try:
+                        cb(experiment, result)
+                    except Exception:
+                        pass
 
     def run(self, experiment: Experiment) -> Result:
         # result = self._run(experiment)
@@ -956,8 +971,8 @@ class GrowthBook(object):
             try:
                 self._trackingCallback(experiment=experiment, result=result, user_context=user_context)
                 self._tracked[key] = True
-            except Exception:
-                pass
+            except Exception as e:
+                logger.exception(e)
 
     def _derive_sticky_bucket_identifier_attributes(self) -> List[str]:
         attributes = set()

{growthbook-1.4.5 → growthbook-1.4.7}/growthbook/growthbook_client.py

@@ -81,7 +81,7 @@ class WeakRefWrapper:
 class FeatureCache:
     """Thread-safe feature cache"""
     def __init__(self):
-        self._cache = {
+        self._cache: Dict[str, Dict[str, Any]] = {
             'features': {},
             'savedGroups': {}
         }
@@ -114,7 +114,7 @@ class EnhancedFeatureRepository(FeatureRepository, metaclass=SingletonMeta):
         self._backoff = BackoffStrategy()
         self._feature_cache = FeatureCache()
         self._callbacks: List[Callable[[Dict[str, Any]], Awaitable[None]]] = []
-        self._last_successful_refresh = None
+        self._last_successful_refresh: Optional[datetime] = None
         self._refresh_in_progress = asyncio.Lock()
 
     @asynccontextmanager
@@ -503,7 +503,7 @@ class GrowthBookClient:
             # Call feature usage callback if provided
             if self.options.on_feature_usage:
                 try:
-                    self.options.on_feature_usage(key, result)
+                    self.options.on_feature_usage(key, result, user_context)
                 except Exception:
                     logger.exception("Error in feature usage callback")
             return result
@@ -516,7 +516,7 @@ class GrowthBookClient:
             # Call feature usage callback if provided
             if self.options.on_feature_usage:
                 try:
-                    self.options.on_feature_usage(key, result)
+                    self.options.on_feature_usage(key, result, user_context)
                 except Exception:
                     logger.exception("Error in feature usage callback")
             return result.on
@@ -529,7 +529,7 @@ class GrowthBookClient:
             # Call feature usage callback if provided
             if self.options.on_feature_usage:
                 try:
-                    self.options.on_feature_usage(key, result)
+                    self.options.on_feature_usage(key, result, user_context)
                 except Exception:
                     logger.exception("Error in feature usage callback")
             return result.off
@@ -541,7 +541,7 @@ class GrowthBookClient:
             # Call feature usage callback if provided
             if self.options.on_feature_usage:
                 try:
-                    self.options.on_feature_usage(key, result)
+                    self.options.on_feature_usage(key, result, user_context)
                 except Exception:
                     logger.exception("Error in feature usage callback")
             return result.value if result.value is not None else fallback

{growthbook-1.4.5 → growthbook-1.4.7}/growthbook/plugins/growthbook_tracking.py

@@ -6,7 +6,7 @@ from typing import Dict, Any, Optional, List, Callable, TYPE_CHECKING
 from .base import GrowthBookPlugin
 
 if TYPE_CHECKING:
-    import requests  # type: ignore
+    import requests
 else:
     try:
         import requests  # type: ignore

{growthbook-1.4.5 → growthbook-1.4.7}/growthbook/plugins/request_context.py

@@ -164,9 +164,10 @@ class RequestContextPlugin(GrowthBookPlugin):
         
         # 3. Try thread-local storage
         import threading
+        from typing import cast
         thread_local = getattr(threading.current_thread(), 'gb_request_context', None)
         if thread_local:
-            return thread_local
+            return cast(Dict[str, Any], thread_local)
         
         return None
     

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.4.5
+Version: 1.4.7
 Summary: Powerful Feature flagging and A/B testing for Python apps
 Home-page: https://github.com/growthbook/growthbook-python
 Author: GrowthBook
@@ -18,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Typing :: Typed
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -56,6 +57,24 @@ Powerful Feature flagging and A/B testing for Python apps.
 
 `pip install growthbook` (recommended) or copy `growthbook.py` into your project
 
+## Type Checking Support
+
+The GrowthBook Python SDK is fully typed and includes inline type hints for all public APIs. This enables:
+
+- **Better IDE support** with autocomplete and inline documentation
+- **Type safety** - catch bugs at development time with mypy or other type checkers
+- **Better code documentation** - types serve as inline documentation
+- **Safer refactoring** - type checkers will catch breaking changes
+
+To use type checking with mypy:
+
+```bash
+pip install mypy
+mypy your_code.py
+```
+
+The SDK includes a `py.typed` marker file and is compliant with [PEP 561](https://www.python.org/dev/peps/pep-0561/).
+
 ## Quick Usage
 
 ```python
@@ -499,7 +518,6 @@ class MyStickyBucketService(AbstractStickyBucketService):
         })
 
 # Pass in an instance of this service to your GrowthBook constructor
-
 gb = GrowthBook(
   sticky_bucket_service = MyStickyBucketService()
 )

{growthbook-1.4.5 → growthbook-1.4.7}/pyproject.toml

@@ -5,6 +5,33 @@ asyncio_default_fixture_loop_scope = "function"
 testpaths = ["tests"]
 pythonpath = "."
 
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false  # Set to false initially, will enable gradually
+disallow_incomplete_defs = false
+check_untyped_defs = true
+disallow_untyped_decorators = false
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true
+show_error_codes = true
+pretty = true
+
+# Per-module options
+[[tool.mypy.overrides]]
+module = "growthbook.*"
+disallow_untyped_defs = false  # Will enable after fixing all type hints
+
+[[tool.mypy.overrides]]
+module = "tests.*"
+disallow_untyped_defs = false
+check_untyped_defs = false
+
 [project]
 dynamic = ["version"]
 name = "growthbook"
@@ -37,6 +64,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
 ]
 
 [build-system]

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

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

{growthbook-1.4.5 → growthbook-1.4.7}/setup.py

@@ -46,6 +46,7 @@ setup(
         'Programming Language :: Python :: 3.10',
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
+        'Typing :: Typed',
     ],
     description="Powerful Feature flagging and A/B testing for Python apps",
     long_description=long_description,

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

@@ -219,8 +219,8 @@ def test_feature_usage_callback():
     """Test that feature usage callback is called correctly"""
     calls = []
     
-    def feature_usage_cb(key, result):
-        calls.append([key, result])
+    def feature_usage_cb(key, result, user_context):
+        calls.append([key, result, user_context])
     
     gb = GrowthBook(
         attributes={"id": "1"},
@@ -243,12 +243,14 @@ def test_feature_usage_callback():
     assert calls[0][0] == "feature-1"
     assert calls[0][1].value is True
     assert calls[0][1].source == "defaultValue"
+    assert calls[0][2].attributes == {"id": "1"}
     
     # Test is_on
     gb.is_on("feature-2")
     assert len(calls) == 2
     assert calls[1][0] == "feature-2"
     assert calls[1][1].value is False
+    assert calls[1][2].attributes == {"id": "1"}
     
     # Test get_feature_value
     value = gb.get_feature_value("feature-3", "blue")
@@ -256,11 +258,13 @@ def test_feature_usage_callback():
     assert calls[2][0] == "feature-3"
     assert calls[2][1].value == "red"
     assert value == "red"
+    assert calls[2][2].attributes == {"id": "1"}
     
     # Test is_off
     gb.is_off("feature-1")
     assert len(calls) == 4
     assert calls[3][0] == "feature-1"
+    assert calls[3][2].attributes == {"id": "1"}
     
     # Calling same feature multiple times should trigger callback each time
     gb.eval_feature("feature-1")
@@ -273,7 +277,7 @@ def test_feature_usage_callback():
 def test_feature_usage_callback_error_handling():
     """Test that feature usage callback errors are handled gracefully"""
     
-    def failing_callback(key, result):
+    def failing_callback(key, result, user_context):
         raise Exception("Callback error")
     
     gb = GrowthBook(
@@ -318,6 +322,68 @@ def test_handles_weird_experiment_values():
     gb.destroy()
 
 
+def test_skip_all_experiments_flag():
+    """Test that skip_all_experiments flag prevents users from being put into experiments"""
+    
+    # Test with skip_all_experiments=True
+    gb_skip = GrowthBook(
+        attributes={"id": "1"},
+        skip_all_experiments=True,
+        features={
+            "feature-with-experiment": Feature(
+                defaultValue="control",
+                rules=[
+                    FeatureRule(
+                        key="exp-123",
+                        variations=["control", "variation"],
+                        weights=[0.5, 0.5]
+                    )
+                ]
+            )
+        }
+    )
+    
+    # User should NOT be in experiment due to skip_all_experiments flag
+    result = gb_skip.eval_feature("feature-with-experiment")
+    assert result.value == "control"  # Should get default value
+    assert result.source == "defaultValue"
+    assert result.experiment is None  # No experiment should be assigned
+    assert result.experimentResult is None
+    
+    # Test running experiment directly
+    exp = Experiment(key="direct-exp", variations=["a", "b"])
+    exp_result = gb_skip.run(exp)
+    assert exp_result.inExperiment is False
+    assert exp_result.value == "a"  # Should get first variation (control)
+    
+    gb_skip.destroy()
+    
+    # Test with skip_all_experiments=False (default behavior)
+    gb_normal = GrowthBook(
+        attributes={"id": "1"},
+        skip_all_experiments=False,  # explicit False
+        features={
+            "feature-with-experiment": Feature(
+                defaultValue="control",
+                rules=[
+                    FeatureRule(
+                        key="exp-123",
+                        variations=["control", "variation"],
+                        weights=[0.5, 0.5]
+                    )
+                ]
+            )
+        }
+    )
+    
+    # User SHOULD be in experiment normally
+    result_normal = gb_normal.eval_feature("feature-with-experiment")
+    # With id="1", this user should be assigned a variation
+    assert result_normal.value in ["control", "variation"]
+    assert result_normal.source == "experiment"
+    
+    gb_normal.destroy()
+
 def test_force_variation():
     gb = GrowthBook(attributes={"id": "6"})
     exp = Experiment(key="forced-test", variations=[0, 1])

{growthbook-1.4.5 → growthbook-1.4.7}/tests/test_growthbook_client.py

@@ -776,8 +776,8 @@ async def test_feature_usage_callback():
     """Test that feature usage callback is called correctly"""
     calls = []
     
-    def feature_usage_cb(key, result):
-        calls.append([key, result])
+    def feature_usage_cb(key, result, user_context):
+        calls.append([key, result, user_context])
     
     client = GrowthBookClient(Options(
         api_host="https://localhost.growthbook.io",
@@ -820,12 +820,14 @@ async def test_feature_usage_callback():
             assert calls[0][0] == "feature-1"
             assert calls[0][1].value is True
             assert calls[0][1].source == "defaultValue"
+            assert calls[0][2].attributes == {"id": "1"}
             
             # Test is_on
             await client.is_on("feature-2", user_context)
             assert len(calls) == 2
             assert calls[1][0] == "feature-2"
             assert calls[1][1].value is False
+            assert calls[1][2].attributes == {"id": "1"}
             
             # Test get_feature_value
             value = await client.get_feature_value("feature-3", "blue", user_context)
@@ -833,11 +835,13 @@ async def test_feature_usage_callback():
             assert calls[2][0] == "feature-3"
             assert calls[2][1].value == "red"
             assert value == "red"
+            assert calls[2][2].attributes == {"id": "1"}
             
             # Test is_off
             await client.is_off("feature-1", user_context)
             assert len(calls) == 4
             assert calls[3][0] == "feature-1"
+            assert calls[3][2].attributes == {"id": "1"}
             
             # Calling same feature multiple times should trigger callback each time
             await client.eval_feature("feature-1", user_context)
@@ -852,7 +856,7 @@ async def test_feature_usage_callback():
 async def test_feature_usage_callback_error_handling():
     """Test that feature usage callback errors are handled gracefully"""
     
-    def failing_callback(key, result):
+    def failing_callback(key, result, user_context):
         raise Exception("Callback error")
     
     client = GrowthBookClient(Options(
@@ -891,5 +895,78 @@ async def test_feature_usage_callback_error_handling():
             is_on = await client.is_on("feature-1", user_context)
             assert is_on is True
             
+    finally:
+        await client.close()
+
+
+@pytest.mark.asyncio
+async def test_skip_all_experiments_flag():
+    """Test that skip_all_experiments flag prevents users from being put into experiments"""
+    
+    client = GrowthBookClient(Options(
+        api_host="https://localhost.growthbook.io",
+        client_key="test-key",
+        enabled=True
+    ))
+    
+    # User context WITH skip_all_experiments=True
+    user_context_skip = UserContext(
+        attributes={"id": "1"},
+        skip_all_experiments=True
+    )
+    
+    # User context WITHOUT skip_all_experiments (normal behavior)
+    user_context_normal = UserContext(
+        attributes={"id": "1"},
+        skip_all_experiments=False
+    )
+    
+    try:
+        # Set up mocks for feature repository
+        mock_features = {
+            "features": {
+                "feature-with-experiment": {
+                    "defaultValue": "control",
+                    "rules": [
+                        {
+                            "key": "exp-123",
+                            "variations": ["control", "variation"],
+                            "weights": [0.5, 0.5]
+                        }
+                    ]
+                }
+            },
+            "savedGroups": {}
+        }
+        
+        with patch('growthbook.FeatureRepository.load_features_async', 
+                  new_callable=AsyncMock, return_value=mock_features), \
+             patch('growthbook.growthbook_client.EnhancedFeatureRepository.start_feature_refresh',
+                  new_callable=AsyncMock), \
+             patch('growthbook.growthbook_client.EnhancedFeatureRepository.stop_refresh',
+                  new_callable=AsyncMock):
+            
+            # Initialize client
+            await client.initialize()
+            
+            # Test with skip_all_experiments=True
+            result_skip = await client.eval_feature("feature-with-experiment", user_context_skip)
+            assert result_skip.value == "control"  # Should get default value
+            assert result_skip.source == "defaultValue"
+            assert result_skip.experiment is None
+            assert result_skip.experimentResult is None
+            
+            # Test direct experiment run with skip_all_experiments=True
+            exp = Experiment(key="direct-exp", variations=["a", "b"])
+            exp_result_skip = await client.run(exp, user_context_skip)
+            assert exp_result_skip.inExperiment is False
+            assert exp_result_skip.value == "a"  # Should get first variation
+            
+            # Test with skip_all_experiments=False (normal)
+            result_normal = await client.eval_feature("feature-with-experiment", user_context_normal)
+            # User should be assigned to a variation
+            assert result_normal.value in ["control", "variation"]
+            assert result_normal.source == "experiment"
+            
     finally:
         await client.close()