growthbook 1.4.6__tar.gz → 1.4.8__tar.gz

{growthbook-1.4.6/growthbook.egg-info → growthbook-1.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: growthbook
-Version: 1.4.6
+Version: 1.4.8
 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

{growthbook-1.4.6 → growthbook-1.4.8}/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

{growthbook-1.4.6 → growthbook-1.4.8}/growthbook/__init__.py

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

{growthbook-1.4.6 → growthbook-1.4.8}/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:

{growthbook-1.4.6 → growthbook-1.4.8}/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