kameleoon-client-python 3.8.0__tar.gz → 3.10.0__tar.gz

{kameleoon-client-python-3.8.0 → kameleoon-client-python-3.10.0}/PKG-INFO

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

{kameleoon-client-python-3.8.0 → kameleoon-client-python-3.10.0}/kameleoon/configuration/data_file.py

@@ -1,10 +1,11 @@
 """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.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
@@ -52,6 +53,7 @@ class DataFile:
         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()
@@ -81,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"""
@@ -146,6 +153,18 @@ class DataFile:
                         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.8.0 → kameleoon-client-python-3.10.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.10.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.10.0/kameleoon/data/cbscores.py

@@ -0,0 +1,66 @@
+"""CBScores"""
+
+from typing import Dict, Iterable, List
+from kameleoon.helpers.string_utils import StringUtils
+from kameleoon.data import DataType
+from kameleoon.data.data import BaseData
+
+
+# pylint: disable=R0903
+class ScoredVarId:
+    """ScoredVarId"""
+    def __init__(self, variation_id: int, score: float) -> None:
+        self.variation_id = variation_id
+        self.score = score
+
+
+class VarGroup:
+    """VarGroup"""
+    def __init__(self, ids: List[int]) -> None:
+        ids.sort()
+        self.__ids = ids
+
+    @property
+    def ids(self) -> List[int]:
+        """Returns the IDs"""
+        return self.__ids
+
+    def __str__(self) -> str:
+        return f"VarGroup{{ids:{self.__ids}}}"
+
+
+class CBScores(BaseData):
+    """CBScores"""
+
+    def __init__(self, cbs_map: Dict[int, Iterable[ScoredVarId]]) -> None:
+        super().__init__()
+        self.__values = {cbs_key: self.__extract_var_ids(cbs_value) for cbs_key, cbs_value in cbs_map.items()}
+
+    @property
+    def values(self) -> Dict[int, List[VarGroup]]:
+        """
+        Returns the CB variation groups stored by experiment.
+
+        keys = experiment IDs / values = list of variation IDs ordered descending
+        by score (there may be several variation ids with same score)
+        """
+        return self.__values
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.CBS
+
+    @staticmethod
+    def __extract_var_ids(scores: Iterable[ScoredVarId]) -> List[VarGroup]:
+        grouped: Dict[float, List[int]] = {}
+        for score in scores:
+            glist = grouped.get(score.score)
+            if glist:
+                glist.append(score.variation_id)
+            else:
+                grouped[score.score] = [score.variation_id]
+        return [VarGroup(grouped[score]) for score in sorted(grouped, reverse=True)]
+
+    def __str__(self) -> str:
+        values = StringUtils.object_to_string(self.__values)
+        return f"CBScores{{values:{values}}}"

{kameleoon-client-python-3.8.0 → kameleoon-client-python-3.10.0}/kameleoon/data/data.py

@@ -22,6 +22,7 @@ class DataType(IntEnum):
     UNIQUE_IDENTIFIER = 13
     FORCED_EXPERIMENT_VARIATION = 14
     FORCED_FEATURE_VARIATION = 15
+    CBS = 16
 
 
 class BaseData:

{kameleoon-client-python-3.8.0 → kameleoon-client-python-3.10.0}/kameleoon/data/manager/visitor.py

@@ -5,6 +5,7 @@ from typing import Any, Callable, Optional, Dict, List, Iterator, Iterable, cast
 from kameleoon.data.visitor_visits import VisitorVisits
 from kameleoon.data.data import Data
 from kameleoon.data.browser import Browser
+from kameleoon.data.cbscores import CBScores
 from kameleoon.data.conversion import Conversion
 from kameleoon.data.cookie import Cookie
 from kameleoon.data.custom_data import CustomData
@@ -172,6 +173,13 @@ class Visitor:  # pylint: disable=R0904
         KameleoonLogger.debug('CALL/RETURN: Visitor.kcs_heat -> (kcs_heat: %s)', kcs_heat)
         return kcs_heat
 
+    @property
+    def cbscores(self) -> Optional[CBScores]:
+        """Returns the CBS data associated with this Visitor."""
+        cbs = self._data.cbscores
+        KameleoonLogger.debug('CALL/RETURN: Visitor.cbscores -> (cbs: %s)', cbs)
+        return cbs
+
     @property
     def visitor_visits(self) -> Optional[VisitorVisits]:
         """Returns the visitor visits data associated with this Visitor."""
@@ -261,6 +269,7 @@ class Visitor:  # pylint: disable=R0904
             self.forced_variations: Optional[Dict[int, ForcedExperimentVariation]] = None
             self.simulated_variations: Optional[Dict[str, ForcedFeatureVariation]] = None
             self.kcs_heat: Optional[KcsHeat] = None
+            self.cbscores: Optional[CBScores] = None
             self.visitor_visits: Optional[VisitorVisits] = None
             self.mapping_identifier: Optional[str] = None
             self.legal_consent = False
@@ -403,6 +412,10 @@ class Visitor:  # pylint: disable=R0904
     def _set_kcs_heat(self, context: DataAddingContext) -> None:
         self._data.kcs_heat = cast(KcsHeat, context.data)
 
+    def _set_cbscores(self, context: DataAddingContext) -> None:
+        if context.overwrite or self._data.cbscores is None:
+            self._data.cbscores = cast(CBScores, context.data)
+
     def _set_visitor_visits(self, context: DataAddingContext) -> None:
         self._data.visitor_visits = cast(VisitorVisits, context.data)
 
@@ -425,6 +438,7 @@ class Visitor:  # pylint: disable=R0904
         PageViewVisit: _add_page_view_visit,
         Conversion: _add_conversion,
         KcsHeat: _set_kcs_heat,
+        CBScores: _set_cbscores,
         VisitorVisits: _set_visitor_visits,
         AssignedVariation: _add_variation,
         ForcedFeatureVariation: _add_forced_feature_variation,

{kameleoon-client-python-3.8.0 → kameleoon-client-python-3.10.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.8.0 → kameleoon-client-python-3.10.0}/kameleoon/helpers/hasher.py

@@ -19,6 +19,11 @@ class Hasher:
             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)