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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.4.0
+Version: 3.6.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.6.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.6.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.6.0}/kameleoon/data/manager/page_view_visit.py

@@ -1,4 +1,5 @@
 """Page view visit"""
+
 import time
 from typing import Optional
 from kameleoon.data import DataType
@@ -8,6 +9,7 @@ from kameleoon.data.page_view import PageView
 
 class PageViewVisit(BaseData):
     """Page view visit"""
+
     def __init__(self, page_view: PageView, count=1, last_timestamp: Optional[int] = None) -> None:
         super().__init__()
         self.page_view = page_view
@@ -18,6 +20,7 @@ class PageViewVisit(BaseData):
         """Overwrites the current PageView with a new PageView and increments the visit count."""
         self.page_view = new_page_view
         self.count += 1
+        self.last_timestamp = int(time.time() * 1000)
 
     def merge(self, page_view_visit) -> None:
         """Merges the visit data from another PageViewVisit instance into this one."""
@@ -33,8 +36,12 @@ class PageViewVisit(BaseData):
         return DataType.PAGE_VIEW_VISIT
 
     def __eq__(self, other: object) -> bool:
-        return isinstance(other, PageViewVisit) and (other.page_view == self.page_view) and (
-            other.count == self.count) and (other.last_timestamp == self.last_timestamp)
+        return (
+            isinstance(other, PageViewVisit)
+            and (other.page_view == self.page_view)
+            and (other.count == self.count)
+            and (other.last_timestamp == self.last_timestamp)
+        )
 
     def __str__(self):
         return (

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.6.0}/kameleoon/data/manager/visitor.py

@@ -174,7 +174,12 @@ class Visitor:
     @mapping_identifier.setter
     def mapping_identifier(self, value: str):
         """Sets the mapping identifier for this Visitor."""
-        self._data.mapping_identifier = value
+        if self._data.mapping_identifier:
+            return
+        with self._data.lock:
+            if self._data.mapping_identifier:
+                return
+            self._data.mapping_identifier = value
         KameleoonLogger.debug("CALL/RETURN: Visitor.mapping_identifier <- (mapping_identifier: %s)", value)
 
     @property

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.6.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.6.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.6.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.6.0}/kameleoon/managers/remote_data/remote_data_manager.py

@@ -1,8 +1,6 @@
 """Remote data"""
 from typing import Optional, Any, List
-from kameleoon.configuration.custom_data_info import CustomDataInfo
 from kameleoon.data import Data
-from kameleoon.data.data import BaseData
 from kameleoon.data.manager.visitor_manager import VisitorManager
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.managers.data.data_manager import DataManager
@@ -53,33 +51,35 @@ class RemoteDataManager:
             data_filter = RemoteVisitorDataFilter()
         service: DataService = self._network_manager.get_service(DataService)
         response = await service.get_remote_visitor_data(visitor_code, data_filter, is_unique_identifier, timeout)
-        visitor_data = self.__handle_remote_visitor_data_response(response, visitor_code, add_data)
+        visitor_data = self.__handle_remote_visitor_data_response(response, visitor_code, add_data, data_filter)
         KameleoonLogger.debug(
             "CALL: RemoteDataManager.get_visitor_data(visitor_code: %s, add_data: %s, data_filter: %s, timeout: %s) "
             "-> (visitor_data: %s)", visitor_code, add_data, data_filter, timeout, visitor_data)
         return visitor_data
 
     def __handle_remote_visitor_data_response(
-        self, response: Response, visitor_code: str, add_data: bool
+        self, response: Response, visitor_code: str, add_data: bool, data_filter: RemoteVisitorDataFilter
     ) -> List[Data]:
         if response.content is None:
             return []
         custom_data_info = self._data_manager.data_file.custom_data_info
-        data_to_add, data_to_return = RemoteDataManager.__parse_remote_visitor_data(custom_data_info, response.content)
+        remote_visitor_data = RemoteDataManager.__parse_remote_visitor_data(response.content)
+        remote_visitor_data.mark_data_as_sent(custom_data_info)
+        data_to_add = remote_visitor_data.collect_data_to_add()
         if add_data and data_to_add:
             # Cannot use `VisitorManager.add_data` because it could use remote visitor data for mapping.
             visitor = self._visitor_manager.get_or_create_visitor(visitor_code)
             visitor.add_data(*data_to_add, overwrite=False)
-        return data_to_return
+        if data_filter.visitor_code and remote_visitor_data.visitor_code:
+            # We apply visitor code from the latest visit fetched from Data API
+            visitor = self._visitor_manager.get_or_create_visitor(visitor_code)
+            visitor.mapping_identifier = remote_visitor_data.visitor_code
+        return remote_visitor_data.collect_data_to_return()
 
     @staticmethod
-    def __parse_remote_visitor_data(
-            custom_data_info: CustomDataInfo, raw: Any
-    ) -> tuple[List[BaseData], List[Data]]:
+    def __parse_remote_visitor_data(raw: Any) -> RemoteVisitorData:
         try:
-            remote_visitor_data = RemoteVisitorData(raw)
-            remote_visitor_data.mark_data_as_sent(custom_data_info)
-            return remote_visitor_data.collect_data_to_add(), remote_visitor_data.collect_data_to_return()
+            return RemoteVisitorData(raw)
         except Exception as ex:  # pylint: disable=W0703
             KameleoonLogger.error("Parsing of remote visitor data failed: %s", ex)
-            return [], []
+            return RemoteVisitorData({})

{kameleoon-client-python-3.4.0 → kameleoon-client-python-3.6.0}/kameleoon/managers/remote_data/remote_visitor_data.py

@@ -38,6 +38,7 @@ class RemoteVisitorData:
         self.__experiments: Optional[Dict[int, AssignedVariation]] = None
         self.__conversions: Optional[List[Conversion]] = None
         self.__previous_visitor_visits: Optional[VisitorVisits] = None
+        self.__visitor_code: Optional[str] = None
         current_visit = json.get("currentVisit")
         if current_visit is not None:
             self.__parse_visit(current_visit)
@@ -100,7 +101,14 @@ class RemoteVisitorData:
             for conversion in self.__conversions:
                 conversion.mark_as_sent()
 
+    @property
+    def visitor_code(self) -> Optional[str]:
+        """Returns the `visitorCode` from the most recent visit"""
+        return self.__visitor_code
+
     def __parse_visit(self, json_visit: Dict[str, Any]) -> None:
+        if (self.__visitor_code is None) and isinstance(visitor_code := json_visit.get("visitorCode"), str):
+            self.__visitor_code = visitor_code
         custom_data_events = json_visit.get("customDataEvents")
         if custom_data_events:
             self.__parse_custom_data(custom_data_events)