kameleoon-client-python 3.7.0__tar.gz → 3.9.0__tar.gz

{kameleoon-client-python-3.7.0 → kameleoon-client-python-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.7.0
+Version: 3.9.0
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon

{kameleoon-client-python-3.7.0 → kameleoon-client-python-3.9.0}/kameleoon/configuration/data_file.py

@@ -1,12 +1,14 @@
 """Kameleoon Configuration"""
 
-from typing import Any, Dict, Optional, Set
+from typing import Any, Dict, Iterable, List, Optional, Set
 from kameleoon.configuration import Variable
 from kameleoon.configuration.custom_data_info import CustomDataInfo
-from kameleoon.configuration.variation_by_exposition import VariationByExposition
+from kameleoon.configuration.experiment import Experiment
 from kameleoon.configuration.feature_flag import FeatureFlag
+from kameleoon.configuration.me_group import MEGroup
 from kameleoon.configuration.rule import Rule
 from kameleoon.configuration.settings import Settings
+from kameleoon.configuration.variation_by_exposition import VariationByExposition
 from kameleoon.exceptions import FeatureNotFound, FeatureEnvironmentDisabled
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 
@@ -31,7 +33,8 @@ class DataFile:
             for jobj in configuration.get("featureFlags") or []
         }
         custom_data_info = CustomDataInfo(configuration.get("customData"))
-        data_file = DataFile(environment, settings, feature_flags, custom_data_info)
+        holdout = Experiment.from_json(configuration["holdout"]) if "holdout" in configuration else None
+        data_file = DataFile(environment, settings, feature_flags, custom_data_info, holdout)
         return data_file
 
     # pylint: disable=R0913
@@ -41,13 +44,16 @@ class DataFile:
         settings: Settings,
         feature_flags: Dict[str, FeatureFlag],
         custom_data_info: CustomDataInfo,
+        holdout: Optional[Experiment] = None,
     ) -> None:
         KameleoonLogger.debug(
-            'CALL: DataFile(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s)',
-            environment, settings, feature_flags, custom_data_info)
+            'CALL: DataFile(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s, holdout: %s)',
+            environment, settings, feature_flags, custom_data_info, holdout
+        )
         self.__environment = environment  # pylint: disable=W0238
         self.__settings = settings
         self.__feature_flags: Dict[str, FeatureFlag] = feature_flags
+        self.__me_groups = self.__make_me_groups(feature_flags.values())
         self.__has_any_targeted_delivery_rule = any(
             rule.is_targeted_delivery
             for ff in self.__feature_flags.values()
@@ -61,9 +67,11 @@ class DataFile:
         self.__experiment_ids_with_js_css_variable: Set[int] = set()
         self.__collect_indices()
         self.__custom_data_info = custom_data_info
+        self.__holdout = holdout
         KameleoonLogger.debug(
-            'RETURN: DataFile.new(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s)',
-            environment, settings, feature_flags, custom_data_info)
+            'RETURN: DataFile.new(environment: %s, settings: %s, feature_flags: %s, custom_data_info: %s, holdout: %s)',
+            environment, settings, feature_flags, custom_data_info
+        )
 
     @property
     def settings(self) -> Settings:
@@ -75,6 +83,11 @@ class DataFile:
         """Returns dictionary of all feature flags stored by feature keys"""
         return self.__feature_flags
 
+    @property
+    def me_groups(self) -> Dict[str, MEGroup]:
+        """Returns the mutually exclusive groups by their names"""
+        return self.__me_groups
+
     @property
     def feature_flag_by_id(self) -> Dict[int, FeatureFlag]:
         """Returns dictionary of all feature flags stored by id"""
@@ -114,9 +127,14 @@ class DataFile:
 
     @property
     def custom_data_info(self) -> CustomDataInfo:
-        """Returns custom data info for mapping device`"""
+        """Returns custom data info for mapping device"""
         return self.__custom_data_info
 
+    @property
+    def holdout(self) -> Optional[Experiment]:
+        """Returns holdout"""
+        return self.__holdout
+
     def has_experiment_js_css_variable(self, experiment_id: int) -> bool:
         """Returns `True` if the experiment has a JS or CSS variable, otherwise returns `False`"""
         return experiment_id in self.__experiment_ids_with_js_css_variable
@@ -128,13 +146,25 @@ class DataFile:
                 has_feature_flag_variable_js_css = self.__has_feature_flag_variable_js_css(feature_flag)
                 for rule in feature_flag.rules:
                     self.__rule_by_segment_id[rule.segment_id] = rule
-                    self.__rule_info_by_exp_id[rule.experiment_id] = DataFile.RuleInfo(feature_flag, rule)
+                    self.__rule_info_by_exp_id[rule.experiment.id_] = DataFile.RuleInfo(feature_flag, rule)
                     if has_feature_flag_variable_js_css:
-                        self.__experiment_ids_with_js_css_variable.add(rule.experiment_id)
-                    for variation in rule.variation_by_exposition:
+                        self.__experiment_ids_with_js_css_variable.add(rule.experiment.id_)
+                    for variation in rule.experiment.variations_by_exposition:
                         if variation.variation_id is not None:
                             self.__variation_by_id[variation.variation_id] = variation
 
+    @staticmethod
+    def __make_me_groups(feature_flags: Iterable[FeatureFlag]) -> Dict[str, MEGroup]:
+        me_group_lists: Dict[str, List[FeatureFlag]] = {}
+        for feature_flag in feature_flags:
+            if feature_flag.me_group_name:
+                me_group_list = me_group_lists.get(feature_flag.me_group_name)
+                if me_group_list:
+                    me_group_list.append(feature_flag)
+                else:
+                    me_group_lists[feature_flag.me_group_name] = [feature_flag]
+        return {me_group_name: MEGroup(me_group_list) for me_group_name, me_group_list in me_group_lists.items()}
+
     @staticmethod
     def __has_feature_flag_variable_js_css(feature_flag: FeatureFlag) -> bool:
         variations = feature_flag.variations

kameleoon-client-python-3.9.0/kameleoon/configuration/experiment.py

@@ -0,0 +1,46 @@
+"""Kameleoon Configuration"""
+
+from typing import Any, List, Dict, Optional
+from kameleoon.configuration.variation_by_exposition import VariationByExposition
+from kameleoon.exceptions import FeatureVariationNotFound
+
+
+class Experiment:
+    """Experiment"""
+
+    def __init__(self, id_: int, variations_by_exposition: List[VariationByExposition]) -> None:
+        self.id_ = id_
+        self.variations_by_exposition = variations_by_exposition
+        self.first_variation = variations_by_exposition[0] if len(variations_by_exposition) > 0 else None
+
+    @staticmethod
+    def from_json(dict_json: Dict[str, Any]) -> "Experiment":
+        """Creates a new instance of `Experiment` from a json object"""
+        id_ = dict_json.get("experimentId", 0)
+        variations_by_exposition: List[VariationByExposition] = VariationByExposition.from_array(
+            dict_json.get("variationByExposition", [])
+        )
+        return Experiment(id_, variations_by_exposition)
+
+    def get_variation(self, hash_double: float) -> Optional[VariationByExposition]:
+        """Calculates the variation key for the given hash of visitor"""
+
+        total = 0.0
+        for var_by_exp in self.variations_by_exposition:
+            total += var_by_exp.exposition
+            if total >= hash_double:
+                return var_by_exp
+        return None
+
+    def get_variation_by_key(self, variation_key: str) -> VariationByExposition:
+        """
+        Finds variation with a passed variation key.
+        Raises the `FeatureVariationNotFound` exception if such variation does not exist.
+        """
+        for var_by_exp in self.variations_by_exposition:
+            if var_by_exp.variation_key == variation_key:
+                return var_by_exp
+        raise FeatureVariationNotFound("'#{variation_key}'")
+
+    def __str__(self) -> str:
+        return f"Experiment{{id:{self.id_}}}"

{kameleoon-client-python-3.7.0 → kameleoon-client-python-3.9.0}/kameleoon/configuration/feature_flag.py

@@ -17,10 +17,11 @@ class FeatureFlag:
         """Create a list of FeatureFlags from the json array"""
         return [FeatureFlag(item) for item in array]
 
-    def __init__(self, dict_json: Dict[str, Any]):
+    def __init__(self, dict_json: Dict[str, Any]) -> None:
         self.id_: int = dict_json.get("id", 0)
         self.feature_key: str = dict_json.get("featureKey", "")
         self.default_variation_key: str = dict_json.get("defaultVariationKey", "")
+        self.me_group_name: Optional[str] = dict_json.get("mutuallyExclusiveGroup")
         self.variations: List[Variation] = Variation.from_array(
             dict_json.get("variations", [])
         )
@@ -39,6 +40,7 @@ class FeatureFlag:
             f"environment_enabled:{self.environment_enabled},"
             f"variations:{StringUtils.object_to_string(self.variations)},"
             f"default_variation_key:'{self.default_variation_key}',"
+            f"me_group_name:'{self.me_group_name}',"
             f"rules:{len(self.rules)}"
             f"}}"
         )

kameleoon-client-python-3.9.0/kameleoon/configuration/me_group.py

@@ -0,0 +1,24 @@
+"""Kameleoon Configuration"""
+
+from typing import List
+from kameleoon.configuration.feature_flag import FeatureFlag
+
+
+class MEGroup:
+    """Represents a mutually exclusive group"""
+
+    def __init__(self, feature_flags: List[FeatureFlag]) -> None:
+        feature_flags.sort(key=lambda ff: ff.id_)
+        self.__feature_flags = feature_flags
+
+    @property
+    def feature_flags(self) -> List[FeatureFlag]:
+        """Returns the feature flags"""
+        return self.__feature_flags
+
+    def get_feature_flag_by_hash(self, hash_double: float) -> FeatureFlag:
+        """Finds a feature flag by the given hash"""
+        idx = int(hash_double * len(self.__feature_flags))
+        if idx >= len(self.__feature_flags):
+            idx = len(self.__feature_flags) - 1
+        return self.__feature_flags[idx]

{kameleoon-client-python-3.7.0 → kameleoon-client-python-3.9.0}/kameleoon/configuration/rule.py

@@ -1,9 +1,8 @@
 """Kameleoon Configuration"""
 
 from typing import Any, List, Dict, Optional
+from kameleoon.configuration.experiment import Experiment
 from kameleoon.configuration.rule_type import RuleType, rule_type_from_literal
-from kameleoon.configuration.variation_by_exposition import VariationByExposition
-from kameleoon.exceptions import FeatureVariationNotFound
 from kameleoon.targeting.models import Segment
 
 
@@ -24,36 +23,12 @@ class Rule:
         type_literal: str = dict_json.get("type", "")
         self.type = rule_type_from_literal(type_literal)
         self.exposition: float = dict_json.get("exposition", 0.0)
-        self.experiment_id: int = dict_json.get("experimentId", 0)
+        self.experiment = Experiment.from_json(dict_json)
         self.respool_time: Optional[int] = dict_json.get("respoolTime", None)
-        self.variation_by_exposition: List[VariationByExposition] = VariationByExposition.from_array(
-            dict_json.get("variationByExposition", [])
-        )
-        self.first_variation = self.variation_by_exposition[0] if len(self.variation_by_exposition) > 0 else None
         segment = dict_json.get("segment")
         self.targeting_segment: Optional[Segment] = Segment(segment) if segment else None
         self.segment_id: int = self.targeting_segment.id_ if self.targeting_segment else -1
 
-    def get_variation(self, hash_double: float) -> Optional[VariationByExposition]:
-        """Calculates the variation key for the given hash of visitor"""
-
-        total = 0.0
-        for var_by_exp in self.variation_by_exposition:
-            total += var_by_exp.exposition
-            if total >= hash_double:
-                return var_by_exp
-        return None
-
-    def get_variation_by_key(self, variation_key: str) -> VariationByExposition:
-        """
-        Finds variation with a passed variation key.
-        Raises the `FeatureVariationNotFound` exception if such variation does not exist.
-        """
-        for var_by_exp in self.variation_by_exposition:
-            if var_by_exp.variation_key == variation_key:
-                return var_by_exp
-        raise FeatureVariationNotFound("'#{variation_key}'")
-
     @property
     def is_experimentation(self) -> bool:
         """Return `true` if rule is `experimentation` type"""

{kameleoon-client-python-3.7.0 → kameleoon-client-python-3.9.0}/kameleoon/data/manager/visitor.py

@@ -347,7 +347,7 @@ class Visitor:  # pylint: disable=R0904
         fev = cast(ForcedExperimentVariation, context.data)
         if self._data.forced_variations is None:
             self._data.forced_variations = {}
-        self._data.forced_variations[fev.rule.experiment_id] = fev
+        self._data.forced_variations[fev.rule.experiment.id_] = fev
 
     def _set_browser(self, context: DataAddingContext) -> None:
         if context.overwrite or self._data.browser is None:

{kameleoon-client-python-3.7.0 → kameleoon-client-python-3.9.0}/kameleoon/exceptions.py

@@ -70,7 +70,7 @@ class FeatureNotFound(NotFoundError):
         super().__init__(self.message)
 
 
-class FeatureExperimentNotFound(NotFoundError):  # //~ Derived from FeatureError in other SDKs
+class FeatureExperimentNotFound(NotFoundError):
     """Exception indicating that the requested experiment has not been found.
     Check that the experiment's ID matches the provided one."""
 

{kameleoon-client-python-3.7.0 → kameleoon-client-python-3.9.0}/kameleoon/helpers/functions.py

@@ -1,46 +1,8 @@
 """Helper functions"""
-import hashlib
 import json
-import math
 import sys
 from enum import Enum
-from typing import Dict, Any, Optional, Union, Type, TypeVar
-
-
-def obtain_hash_double(
-    visitor_code: str, respool_times=None, container_id: str = ""
-) -> float:
-    """Calculate the hash value for a given visitor_code"""
-    return _obtain_hash_double(visitor_code, respool_times, container_id)
-
-
-def obtain_hash_double_rule(
-    visitor_code: str, container_id: int, respool_time: Optional[int] = None
-) -> float:
-    """Calculate the hash value for feature flag v2 for a given visitor_code"""
-    return _obtain_hash_double(
-        visitor_code=visitor_code,
-        container_id=container_id,
-        suffix=str(respool_time) if respool_time else "",
-    )
-
-
-def _obtain_hash_double(
-    visitor_code: str,
-    respool_times=None,
-    container_id: Union[str, int] = "",
-    suffix: str = "",
-) -> float:
-    if respool_times is None:
-        respool_times = {}
-    identifier = visitor_code
-    identifier += str(container_id)
-    identifier += suffix
-    if respool_times:
-        identifier += "".join([str(v) for k, v in sorted(respool_times.items())])
-    return int(hashlib.sha256(identifier.encode("UTF-8")).hexdigest(), 16) / math.pow(
-        2, 256
-    )
+from typing import Dict, Any, Optional, Type, TypeVar
 
 
 def load_params_from_json(json_path) -> Dict[Any, Any]:

kameleoon-client-python-3.9.0/kameleoon/helpers/hasher.py

@@ -0,0 +1,29 @@
+"""Helper hash functions"""
+
+import hashlib
+import math
+from typing import Optional
+
+
+class Hasher:
+    """Hasher"""
+
+    @staticmethod
+    def obtain(
+        visitor_code: str, container_id: int, respool_time: Optional[int] = None
+    ) -> float:
+        """Calculate the hash value for feature flag v2 for a given visitor_code"""
+        identifier = visitor_code
+        identifier += str(container_id)
+        if respool_time:
+            identifier += str(respool_time)
+        return Hasher._calculate(identifier)
+
+    @staticmethod
+    def obtain_hash_for_me_group(visitor_code: str, me_group_name: str) -> float:
+        """Calculate the hash value for a mutually exclusive group for a given visitor code"""
+        return Hasher._calculate(visitor_code + me_group_name)
+
+    @staticmethod
+    def _calculate(str_to_hash: str) -> float:
+        return int(hashlib.sha256(str_to_hash.encode("UTF-8")).hexdigest(), 16) / math.pow(2, 256)