kameleoon-client-python 3.4.0__tar.gz → 3.5.0__tar.gz

{kameleoon-client-python-3.4.0/kameleoon_client_python.egg-info → kameleoon-client-python-3.5.0}/PKG-INFO

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

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0}/kameleoon/configuration/data_file.py

@@ -1,6 +1,7 @@
 """Kameleoon Configuration"""
 
-from typing import Any, Dict, Optional
+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.feature_flag import FeatureFlag
@@ -56,6 +57,7 @@ class DataFile:
         self.__variation_by_id: Dict[int, VariationByExposition] = {}
         self.__rule_by_segment_id: Dict[int, Rule] = {}
         self.__feature_flag_by_id: Dict[int, FeatureFlag] = {}
+        self.__experiment_ids_with_js_css_variable: Set[int] = set()
         self.__collect_indices()
         self.__custom_data_info = custom_data_info
         KameleoonLogger.debug(
@@ -109,16 +111,33 @@ class DataFile:
         """Returns custom data info for mapping device`"""
         return self.__custom_data_info
 
+    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
+
     def __collect_indices(self) -> None:
         for _, feature_flag in self.__feature_flags.items():
             self.__feature_flag_by_id[feature_flag.id_] = feature_flag
             if feature_flag.rules is not None:
+                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
+                    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:
                         if variation.variation_id is not None:
                             self.__variation_by_id[variation.variation_id] = variation
 
+    @staticmethod
+    def __has_feature_flag_variable_js_css(feature_flag: FeatureFlag) -> bool:
+        variations = feature_flag.variations
+        first_variation = next(iter(variations), None)
+        if first_variation:
+            for variable in first_variation.variables:
+                if variable.get_type() in {Variable.Type.CSS.value, Variable.Type.JS.value}:
+                    return True
+        return False
+
     def __str__(self):
         return (
             f"DataFile{{"

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0}/kameleoon/configuration/variable.py

@@ -19,6 +19,8 @@ class Variable:
         JSON = "JSON"
         NUMBER = "NUMBER"
         STRING = "STRING"
+        CSS = "CSS"
+        JS = "JS"
 
     @staticmethod
     def from_array(array: List[Dict[str, Any]]) -> List["Variable"]:
@@ -36,6 +38,8 @@ class Variable:
             Variable.Type.BOOLEAN.value,
             Variable.Type.NUMBER.value,
             Variable.Type.STRING.value,
+            Variable.Type.CSS.value,
+            Variable.Type.JS.value,
         ):
             return self.__value
         if self.__type == Variable.Type.JSON.value and isinstance(self.__value, str):

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0}/kameleoon/helpers/string_utils.py

@@ -23,6 +23,11 @@ class StringUtils:
         hidden_length = max(length - vis_count, vis_count)
         return secret[:length - hidden_length] + hid_ch * hidden_length
 
+    @staticmethod
+    def bool_to_string_lower_case(data: bool) -> str:
+        """Convert a boolean value to a lowercase string."""
+        return "true" if data else "false"
+
     @staticmethod
     def object_to_string(data: Any) -> str:
         """Convert various data types into their string representation."""
@@ -32,7 +37,7 @@ class StringUtils:
         if result is not None:
             return result
         if isinstance(data, bool):
-            return "true" if data else "false"
+            return StringUtils.bool_to_string_lower_case(data)
         if data is None:
             return "None"
         if hasattr(data, '__str__'):

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0}/kameleoon/hybrid/hybrid_manager_impl.py

@@ -2,21 +2,24 @@
 import time
 from typing import Dict, Optional
 from kameleoon.data.manager.assigned_variation import AssignedVariation
+from kameleoon.helpers.string_utils import StringUtils
 from kameleoon.hybrid.hybrid_manager import HybridManager
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
+from kameleoon.managers.data.data_manager import DataManager
 
 
 class HybridManagerImpl(HybridManager):
     """Implementation of HybridManager that generates tracking code for engine integration."""
     TC_INIT = "window.kameleoonQueue=window.kameleoonQueue||[];"
-    TC_ASSIGN_VARIATION_F = "window.kameleoonQueue.push(['Experiments.assignVariation',{0},{1}]);"
-    TC_TRIGGER_F = "window.kameleoonQueue.push(['Experiments.trigger',{0},true]);"
+    TC_ASSIGN_VARIATION_F = "window.kameleoonQueue.push(['Experiments.assignVariation',{0},{1},true]);"
+    TC_TRIGGER_F = "window.kameleoonQueue.push(['Experiments.trigger',{0},{2}]);"
     TC_ASSIGN_VARIATION_TRIGGER_F = TC_ASSIGN_VARIATION_F + TC_TRIGGER_F
 
-    def __init__(self, expiration_period: float) -> None:
+    def __init__(self, expiration_period: float, data_manager: DataManager) -> None:
         KameleoonLogger.debug("CALL: HybridManagerImpl(expiration_period: %s)", expiration_period)
         super().__init__()
         self._expiration_period = expiration_period
+        self._data_manager = data_manager
         KameleoonLogger.debug("RETURN: HybridManagerImpl(expiration_period: %s)", expiration_period)
 
     def get_engine_tracking_code(self, visitor_variations: Optional[Dict[int, AssignedVariation]]) -> str:
@@ -27,7 +30,11 @@ class HybridManagerImpl(HybridManager):
             expiration_time = time.time() - self._expiration_period
             for variation in visitor_variations.values():
                 if variation.assignment_time > expiration_time:
-                    line = self.TC_ASSIGN_VARIATION_TRIGGER_F.format(variation.experiment_id, variation.variation_id)
+                    tracking_only = not (self._data_manager.data_file.
+                                         has_experiment_js_css_variable(variation.experiment_id))
+                    line = self.TC_ASSIGN_VARIATION_TRIGGER_F.format(
+                        variation.experiment_id, variation.variation_id,
+                        StringUtils.bool_to_string_lower_case(tracking_only))
                     lines.append(line)
         tracking_code = "".join(lines)
         KameleoonLogger.debug(

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0}/kameleoon/kameleoon_client.py

@@ -128,7 +128,7 @@ class KameleoonClient:
         self._visitor_manager = VisitorManager(
             self._data_manager, config.session_duration_second, self._async_executor.scheduler
         )
-        self._hybrid_manager = HybridManagerImpl(HYBRID_EXPIRATION_TIME)
+        self._hybrid_manager = HybridManagerImpl(HYBRID_EXPIRATION_TIME, self._data_manager)
 
         self._cookie_manager = CookieManager(self._data_manager, config.top_level_domain)
         atsf = AccessTokenSourceFactory(config.client_id, config.client_secret)
@@ -424,7 +424,7 @@ class KameleoonClient:
                              visitor_code, is_unique_identifier, instant)
 
     def is_feature_active(
-        self, visitor_code: str, feature_key: str, is_unique_identifier: Optional[bool] = None
+        self, visitor_code: str, feature_key: str, is_unique_identifier: Optional[bool] = None, track=True
     ) -> bool:
         """
         Check if feature is active for a given visitor code
@@ -437,7 +437,6 @@ class KameleoonClient:
         You have to make sure that proper error handling is set up in your code as shown in the example to the right
         to catch potential exceptions.
 
-
         :param visitor_code: Unique identifier of the user. This field is mandatory.
         :type visitor_code: str
         :param feature_key: Key of the feature flag you want to expose to a user. This field is mandatory.
@@ -445,18 +444,18 @@ class KameleoonClient:
         :param is_unique_identifier: (Deprecated) Parameter that specifies whether the visitorCode is
         a unique identifier.
         :type is_unique_identifier: Optional[bool]
+        :param track: Optional flag indicating whether tracking of the feature evaluation is enabled (`True`) or
+        disabled (`False`); the default value is `True`.
+        :type track: bool
+
         :return: Value of the feature that is active for a given visitor_code.
         :rtype: bool
 
-
-        :raises:
-            FeatureNotFound: Exception indicating that the requested feature ID has not been found in
-                                          the internal configuration of the SDK. This is usually normal and means that
-                                          the feature flag has not yet been activated on Kameleoon's side
-                                          (but code implementing the feature is already deployed on the
-                                          web-application's side).
-            VisitorCodeInvalid: Raise when the provided visitor code is not valid
-                        (empty, or longer than 255 characters)
+        :raises FeatureNotFound: Exception indicating that the requested feature ID has not been found in
+            the internal configuration of the SDK. This is usually normal and means that the feature flag has not yet
+            been activated on Kameleoon's side (but code implementing the feature is already deployed on
+            the web-application's side).
+        :raises VisitorCodeInvalid: If the visitor code is empty or longer than 255 chars.
 
         Examples:
 
@@ -476,23 +475,158 @@ class KameleoonClient:
                     # Implement new checkout code here
         """
         KameleoonLogger.info(
-            "CALL: KameleoonClient.is_feature_active(visitor_code: %s, feature_key: %s, is_unique_identifier: %s)",
-            visitor_code, feature_key, is_unique_identifier)
+            "CALL: KameleoonClient.is_feature_active(visitor_code: %s, feature_key: %s, is_unique_identifier: %s, "
+            "track: %s)", visitor_code, feature_key, is_unique_identifier, track
+        )
         validate_visitor_code(visitor_code)
         if is_unique_identifier is not None:
             self.__set_unique_identifier(visitor_code, is_unique_identifier)
         try:
-            (_, variation_key) = self.__get_feature_variation_key(visitor_code, feature_key)
+            feature_flag = self._data_manager.data_file.get_feature_flag(feature_key)
+            variation_key, _, _ = self.__get_variation_info(visitor_code, feature_flag, track)
             feature_active = variation_key != configuration.Variation.Type.OFF.value
+            if track:
+                self._tracking_manager.add_visitor_code(visitor_code)
         except FeatureEnvironmentDisabled:
             feature_active = False
         KameleoonLogger.info(
-            "RETURN: KameleoonClient.is_feature_active(visitor_code: %s, feature_key: %s, is_unique_identifier: %s)"
-            " -> (feature_active: %s)", visitor_code, feature_key, is_unique_identifier, feature_active)
+            "RETURN: KameleoonClient.is_feature_active(visitor_code: %s, feature_key: %s, is_unique_identifier: %s, "
+            "track: %s) -> (feature_active: %s)", visitor_code, feature_key, is_unique_identifier, feature_active, track
+        )
         return feature_active
 
+    def get_variation(self, visitor_code: str, feature_key: str, track=True) -> Variation:
+        """
+        Retrieves the variation assigned to the given visitor for a specific feature flag.
+
+        :param visitor_code: The unique identifier of the visitor.
+        :type visitor_code: str
+        :param feature_key: The unique identifier of the feature flag.
+        :type feature_key: str
+        :param track: Optional flag indicating whether tracking of the feature evaluation is enabled (`True`) or
+        disabled (`False`); the default value is `True`.
+        :type track: bool
+
+        :return: The variation assigned to the visitor if the visitor is associated with some rule of the feature flag,
+        otherwise the method returns the default variation of the feature flag.
+        :rtype: Variation
+
+        :raises VisitorCodeInvalid: If the visitor code is empty or longer than 255 chars.
+        :raises FeatureNotFound: Feature Flag isn't found in this configuration.
+        :raises FeatureEnvironmentDisabled: If the requested feature flag is disabled for the current environment.
+        """
+        KameleoonLogger.info(
+            "CALL: KameleoonClient.get_variation(visitor_code: '%s', feature_key: '%s', track: %s)",
+            visitor_code, feature_key, track
+        )
+        validate_visitor_code(visitor_code)
+        feature_flag = self._data_manager.data_file.get_feature_flag(feature_key)
+        variation_key, var_by_exp, rule = self.__get_variation_info(visitor_code, feature_flag, track)
+        external_variation = self.__make_external_variation(
+            variation_key,
+            feature_flag.get_variation(variation_key),
+            var_by_exp.variation_id if var_by_exp else None,
+            rule.experiment_id if rule else None
+        )
+        if track:
+            self._tracking_manager.add_visitor_code(visitor_code)
+        KameleoonLogger.info(
+            "RETURN: KameleoonClient.get_variation(visitor_code: '%s', feature_key: '%s', track: %s)"
+            " -> (variation: %s)", visitor_code, feature_key, track, external_variation
+        )
+        return external_variation
+
+    def get_variations(self, visitor_code: str, only_active=False, track=True) -> Dict[str, Variation]:
+        """
+        Forms a dictionary of variations assigned to a given visitor across all feature flags.
+        This method iterates over all available feature flags and returns the assigned variation for each flag
+        associated with the specified visitor.
+
+        :param visitor_code: The unique identifier of the visitor.
+        :type visitor_code: str
+        :param only_active: Optional flag indicating whether to return variations for active feature flags only (`True`)
+        or for any feature flags (`False`); the default value is `False`.
+        :type only_active: bool
+        :param track: Optional flag indicating whether tracking of the feature evaluation is enabled (`True`) or
+        disabled (`False`); the default value is `True`.
+        :type track: bool
+        :return: A dictionary consisting of feature flag keys as keys and
+        their corresponding variations (or the default variation of that feature flag) as values.
+        :rtype: Dict[str, Variation]
+
+        :raises VisitorCodeInvalid: If the visitor code is empty or longer than 255 chars.
+        """
+        KameleoonLogger.info(
+            "CALL: KameleoonClient.get_variations(visitor_code: '%s', only_active: %s, track: %s)",
+            visitor_code, only_active, track
+        )
+        validate_visitor_code(visitor_code)
+        variations: Dict[str, Variation] = {}
+        for feature_flag in self._data_manager.data_file.feature_flags.values():
+            if not feature_flag.environment_enabled:
+                continue
+            variation_key, var_by_exp, rule = self.__get_variation_info(visitor_code, feature_flag, track)
+            if only_active and (variation_key == configuration.Variation.Type.OFF.value):
+                continue
+            variations[feature_flag.feature_key] = self.__make_external_variation(
+                variation_key,
+                feature_flag.get_variation(variation_key),
+                var_by_exp.variation_id if var_by_exp else None,
+                rule.experiment_id if rule else None
+            )
+        if track:
+            self._tracking_manager.add_visitor_code(visitor_code)
+        KameleoonLogger.info(
+            "RETURN: KameleoonClient.get_variations(visitor_code: '%s', only_active: %s, track: %s)"
+            " -> (variations: %s)", visitor_code, only_active, track, variations
+        )
+        return variations
+
+    def __get_variation_info(
+        self, visitor_code: str, feature_flag: FeatureFlag, track: bool
+    ) -> Tuple[str, Optional[VariationByExposition], Optional[Rule]]:
+        KameleoonLogger.debug(
+            "CALL: KameleoonClient.__get_variation_info(visitor_code: %s, feature_flag: %s, track: %s)",
+            visitor_code, feature_flag, track
+        )
+        var_by_exp, rule = self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
+        variation_key = self.__calculate_variation_key(var_by_exp, rule, feature_flag)
+        self.__save_variation(visitor_code, rule, var_by_exp, track)
+        KameleoonLogger.debug(
+            "RETURN: KameleoonClient.__get_variation_info(visitor_code: %s, feature_flag: %s, track: %s)"
+            " -> (variation_key: %s, variation_by_exposition: %s, rule: %s)",
+            visitor_code, feature_flag, track, variation_key, var_by_exp, rule
+        )
+        return variation_key, var_by_exp, rule
+
+    @staticmethod
+    def __make_external_variation(
+        variation_key: str,
+        internal_variation: Optional[configuration.Variation],
+        variation_id: Optional[int],
+        experiment_id: Optional[int],
+    ) -> Variation:
+        KameleoonLogger.debug(
+            "CALL: KameleoonClient.__make_external_variation(variation_key: %s, internal_variation: %s, "
+            "variation_id: %s, experiment_id: %s)",
+            variation_key, internal_variation, variation_id, experiment_id
+        )
+        variables: Dict[str, Variable] = {}
+        if internal_variation:
+            for variable in internal_variation.variables:
+                variables[variable.key] = Variable(variable.key, variable.get_type(), variable.get_value())
+        variation = Variation(variation_key, variation_id, experiment_id, variables)
+        KameleoonLogger.debug(
+            "RETURN: KameleoonClient.__make_external_variation(variation_key: %s, internal_variation: %s, "
+            "variation_id: %s, experiment_id: %s) -> (variation: %s)",
+            variation_key, internal_variation, variation_id, experiment_id, variation
+        )
+        return variation
+
     def get_feature_variation_variables(self, feature_key: str, variation_key: str) -> Dict[str, Any]:
         """
+        Deprecated function. Please use `get_variation(visitor_code, feature_key, False)` instead.
+
         Retrieve all feature variables.
         A feature variables can be changed easily via our web application.
 
@@ -520,6 +654,10 @@ class KameleoonClient:
         """
 
         # pylint: disable=no-else-raise
+        KameleoonLogger.info(
+            "Call to deprecated function `get_feature_variation_variables`. "
+            "Please use `get_variation(visitor_code, feature_key, False)` instead."
+        )
         KameleoonLogger.info(
             "CALL: KameleoonClient.get_feature_variation_variables(feature_key: %s, variation_key: %s)",
             feature_key, variation_key)
@@ -787,7 +925,7 @@ class KameleoonClient:
 
     def get_active_feature_list_for_visitor(self, visitor_code: str) -> List[str]:
         """
-        Depreacted function. Please use `get_active_features_for_visitor` instead.
+        Deprecated function. Please use `get_active_features_for_visitor` instead.
         The get_active_feature_list_for_visitor method uses for obtaining a list of feature flag IDs:
         - currently targeted and active simultaneously for a visitor
 
@@ -800,8 +938,10 @@ class KameleoonClient:
         """
         KameleoonLogger.info("CALL: KameleoonClient.get_active_feature_list_for_visitor(visitor_code: %s)",
                              visitor_code)
-        KameleoonLogger.warning("Call to deprecated function `get_active_feature_list_for_visitor`. "
-                                "Please use `get_active_features` instead.")
+        KameleoonLogger.info(
+            "Call to deprecated function `get_active_feature_list_for_visitor`. "
+            "Please use `get_active_features` instead."
+        )
 
         def filter_conditions(feature_flag: FeatureFlag) -> bool:
             if not feature_flag.environment_enabled:
@@ -826,6 +966,8 @@ class KameleoonClient:
 
     def get_active_features(self, visitor_code: str) -> Dict[str, Variation]:
         """
+        Deprecated function. Please use `get_variations(visitor_code, True, False)` instead.
+
         The get_active_features method uses for obtaining a information about the active feature flags
          that are available for the visitor.
 
@@ -839,6 +981,10 @@ class KameleoonClient:
         :raises:
             VisitorCodeInvalid: Raise when the provided visitor code is not valid
         """
+        KameleoonLogger.info(
+            "Call to deprecated function `get_active_features`. "
+            "Please use `get_variations(visitor_code, True, False)` instead."
+        )
         KameleoonLogger.info("CALL: KameleoonClient.get_active_features(visitor_code: %s)", visitor_code)
         validate_visitor_code(visitor_code)
         map_active_features: Dict[str, Variation] = {}
@@ -849,16 +995,11 @@ class KameleoonClient:
             variation_key = self.__calculate_variation_key(var_by_exp, rule, feature_flag)
             if variation_key == configuration.Variation.Type.OFF.value:
                 continue
-            variation = feature_flag.get_variation(variation_key)
-            variables: Dict[str, Variable] = {}
-            if variation is not None:
-                for variable in variation.variables:
-                    variables[variable.key] = Variable(variable.key, variable.get_type(), variable.get_value())
-            map_active_features[feature_flag.feature_key] = Variation(
+            map_active_features[feature_flag.feature_key] = self.__make_external_variation(
                 variation_key,
-                var_by_exp.variation_id if var_by_exp is not None else None,
-                rule.experiment_id if rule is not None else None,
-                variables,
+                feature_flag.get_variation(variation_key),
+                var_by_exp.variation_id if var_by_exp else None,
+                rule.experiment_id if rule else None
             )
         KameleoonLogger.info("RETURN: KameleoonClient.get_active_features(visitor_code: %s) -> (active_features: %s)",
                              visitor_code, map_active_features)
@@ -868,6 +1009,8 @@ class KameleoonClient:
         self, visitor_code: str, feature_key: str, is_unique_identifier: Optional[bool] = None
     ) -> str:
         """
+        Deprecated function. Please use `get_variation(visitor_code, feature_key, True)` instead.
+
         Returns a variation key for visitor code
 
         This method takes a visitor_code and feature_key as mandatory arguments and
@@ -898,6 +1041,10 @@ class KameleoonClient:
             FeatureEnvironmentDisabled: Exception indicating that feature flag is disabled for the
                                         visitor's current environment.
         """
+        KameleoonLogger.info(
+            "Call to deprecated function `get_feature_variation_key`. "
+            "Please use `get_variation(visitor_code, feature_key, True)` instead."
+        )
         KameleoonLogger.info(
             "CALL: KameleoonClient.get_feature_variation_key(visitor_code: %s, feature_key: %s, "
             "is_unique_identifier: %s)", visitor_code, feature_key, is_unique_identifier)
@@ -915,6 +1062,8 @@ class KameleoonClient:
         self, visitor_code: str, feature_key: str, variable_key: str, is_unique_identifier: Optional[bool] = None
     ) -> Union[bool, str, float, Dict[str, Any], List[Any], None]:
         """
+        Deprecated function. Please use `get_variation(visitor_code, feature_key, True)` instead.
+
         Retrieves a feature variable value from assigned for visitor variation
         A feature variable can be changed easily via our web application.
 
@@ -943,6 +1092,10 @@ class KameleoonClient:
             FeatureEnvironmentDisabled: Exception indicating that feature flag is disabled for the
                                         visitor's current environment.
         """
+        KameleoonLogger.info(
+            "Call to deprecated function `get_feature_variable`. "
+            "Please use `get_variation(visitor_code, feature_key, True)` instead."
+        )
         KameleoonLogger.info(
             "CALL: KameleoonClient.get_feature_variable(visitor_code: %s, feature_key: %s, "
             "variable_key: %s, is_unique_identifier: %s)",
@@ -1152,30 +1305,31 @@ class KameleoonClient:
         feature_flag = self._data_manager.data_file.get_feature_flag(feature_key)
         (variation, rule) = self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
         variation_key = self.__calculate_variation_key(variation, rule, feature_flag)
-        self.__assign_feature_variation(visitor_code, rule, variation)
+        self.__save_variation(visitor_code, rule, variation)
         self._tracking_manager.add_visitor_code(visitor_code)
         KameleoonLogger.debug(
             "RETURN: KameleoonClient.__get_feature_variation_key(visitor_code: %s, feature_key: %s) -> "
             "(feature_flag: %s, variation_key: %s)", visitor_code, feature_key, feature_flag, variation_key)
         return (feature_flag, variation_key)
 
-    def __assign_feature_variation(
-        self, visitor_code: str, rule: Optional[Rule], variation: Optional[VariationByExposition]
+    def __save_variation(
+        self, visitor_code: str, rule: Optional[Rule], variation: Optional[VariationByExposition], track=True
     ) -> None:
-        if rule is None:
+        if (rule is None) or (variation is None) or (rule.experiment_id is None) or (variation.variation_id is None):
             return
         KameleoonLogger.debug(
-            "CALL: KameleoonClient.__assign_feature_variation(visitor_code: %s, rule: %s, variation: %s)",
-            visitor_code, rule, variation)
+            "CALL: KameleoonClient.__save_variation(visitor_code: %s, rule: %s, variation: %s, track: %s)",
+            visitor_code, rule, variation, track
+        )
         visitor = self._visitor_manager.get_or_create_visitor(visitor_code)
-        experiment_id = rule.experiment_id
-        variation_id = variation.variation_id if variation is not None else None
-        if experiment_id is not None and variation_id is not None:
-            as_variation = AssignedVariation(experiment_id, variation_id, rule.type)
-            visitor.assign_variation(as_variation)
+        as_variation = AssignedVariation(rule.experiment_id, variation.variation_id, rule.type)
+        if not track:
+            as_variation.mark_as_sent()
+        visitor.assign_variation(as_variation)
         KameleoonLogger.debug(
-            "RETURN: KameleoonClient.__assign_feature_variation(visitor_code: %s, rule: %s, variation: %s)",
-            visitor_code, rule, variation)
+            "RETURN: KameleoonClient.__save_variation(visitor_code: %s, rule: %s, variation: %s, track: %s)",
+            visitor_code, rule, variation, track
+        )
 
     def __calculate_variation_rule_for_feature(
         self, visitor_code: str, feature_flag: FeatureFlag
@@ -1247,7 +1401,7 @@ class KameleoonClient:
         return variation_key
 
     def __set_unique_identifier(self, visitor_code: str, is_unique_identifier: bool) -> None:
-        KameleoonLogger.warning(
+        KameleoonLogger.info(
             "The 'is_unique_identifier' parameter is deprecated. Please, add 'UniqueIdentifier' to a visitor instead."
         )
         self._visitor_manager.add_data(visitor_code, UniqueIdentifier(is_unique_identifier))

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0}/kameleoon/network/url_provider.py

@@ -19,7 +19,7 @@ class UrlProvider:
     DEFAULT_DATA_API_DOMAIN = "data.kameleoon.io"
     TEST_DATA_API_DOMAIN = "data.kameleoon.net"
     DEFAULT_AUTOMATION_API_DOMAIN = "api.kameleoon.com"
-    TEST_AUTOMATION_API_DOMAIN = "api.master.preview.kameleoon.net"
+    TEST_AUTOMATION_API_DOMAIN = "api.kameleoon.net"
 
     def __init__(
         self,

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0}/kameleoon/sdk_version.py

@@ -4,7 +4,7 @@ from typing import Optional, Tuple
 
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 
-version_info = (3, 4, 0)
+version_info = (3, 5, 0)
 __version__ = ".".join(str(v) for v in version_info)  # uses in scripts
 
 

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0}/kameleoon/types/variation.py

@@ -1,6 +1,6 @@
 """Variation"""
 from typing import Optional, Dict
-
+from kameleoon import configuration
 from kameleoon.helpers.string_utils import StringUtils
 from kameleoon.types.variable import Variable
 
@@ -35,6 +35,11 @@ class Variation:
         """Return variables"""
         return self.__variables
 
+    @property
+    def is_active(self) -> bool:
+        """Returns if the variation is active"""
+        return self.__key != configuration.Variation.Type.OFF.value
+
     def __str__(self):
         return (f"Variation{{key:'{self.__key}',"
                 f"experiment_id:{self.__experiment_id},"

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.5.0/kameleoon_client_python.egg-info}/PKG-INFO

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