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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.7.0
+Version: 3.8.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.8.0}/kameleoon/configuration/data_file.py

@@ -3,10 +3,11 @@
 from typing import Any, Dict, 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.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 +32,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,10 +43,12 @@ 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
@@ -61,9 +65,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:
@@ -114,9 +120,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,10 +139,10 @@ 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
 

kameleoon-client-python-3.8.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.8.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.8.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.8.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.8.0/kameleoon/helpers/hasher.py

@@ -0,0 +1,24 @@
+"""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 _calculate(str_to_hash: str) -> float:
+        return int(hashlib.sha256(str_to_hash.encode("UTF-8")).hexdigest(), 16) / math.pow(2, 256)