kameleoon-client-python 3.12.1__tar.gz → 3.14.0__tar.gz

{kameleoon-client-python-3.12.1/kameleoon_client_python.egg-info → kameleoon-client-python-3.14.0}/PKG-INFO

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

{kameleoon-client-python-3.12.1 → kameleoon-client-python-3.14.0}/kameleoon/configuration/custom_data_info.py

@@ -17,6 +17,7 @@ class CustomDataInfo:
         self.__mapping_identifier_index = None
         self.__local_only = set()
         self.__visitor_scope = set()
+        self.__custom_data_index_by_id = {}
         if custom_data is not None:
             for data in custom_data:
                 index = data.get("index")
@@ -26,6 +27,8 @@ class CustomDataInfo:
                         self.__local_only.add(index)
                     if data.get("scope") == self.SCOPE_VISITOR:
                         self.__visitor_scope.add(index)
+                    if (id_ := data.get("id")) is not None:
+                        self.__custom_data_index_by_id[id_] = index
                     if data.get("isMappingIdentifier"):
                         if bool(self.__mapping_identifier_index is not None):
                             KameleoonLogger.warning(
@@ -50,3 +53,7 @@ class CustomDataInfo:
     def mapping_identifier_index(self) -> Optional[int]:
         """Take mapping identifier index"""
         return self.__mapping_identifier_index
+
+    def get_custom_data_index_by_id(self, custom_data_id: int) -> Optional[int]:
+        """Get corresponding custom data id by custom data index"""
+        return self.__custom_data_index_by_id.get(custom_data_id)

{kameleoon-client-python-3.12.1 → kameleoon-client-python-3.14.0}/kameleoon/configuration/data_file.py

@@ -11,6 +11,7 @@ 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
+from kameleoon.targeting.models import Segment
 
 
 class DataFile:
@@ -19,38 +20,55 @@ class DataFile:
     @staticmethod
     def default(environment: Optional[str]) -> "DataFile":
         """Creates new instance of `DataFile` initialized with default values"""
-        data_file = DataFile(environment, Settings(), {}, CustomDataInfo(None))
+        data_file = DataFile(environment, None, Settings(), {}, CustomDataInfo(None))
         return data_file
 
     @staticmethod
     def from_json(
-        environment: Optional[str], configuration: Dict[str, Any]
+        environment: Optional[str], last_modified: Optional[str], configuration: Dict[str, Any]
     ) -> "DataFile":
         """Creates new instance of `DataFile` initialized from the specified configuration JSON"""
         settings = Settings(configuration.get("configuration"))
-        feature_flags = {
-            (feature_flag := FeatureFlag(jobj)).feature_key: feature_flag
-            for jobj in configuration.get("featureFlags") or []
-        }
+        segments = DataFile.__parse_segments(configuration)
         custom_data_info = CustomDataInfo(configuration.get("customData"))
+        feature_flags = DataFile.__parse_feature_flags(configuration, segments, 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)
+        data_file = DataFile(environment, last_modified, settings, feature_flags, custom_data_info, holdout)
         return data_file
 
+    @staticmethod
+    def __parse_segments(configuration: Dict[str, Any]) -> Dict[int, Segment]:
+        return {
+            (seg := Segment(jobj)).id_: seg
+            for jobj in configuration.get("segments") or []
+        }
+
+    @staticmethod
+    def __parse_feature_flags(
+        configuration: Dict[str, Any], segments: Dict[int, Segment], cdi: CustomDataInfo
+    ) -> Dict[str, FeatureFlag]:
+        return {
+            (ff := FeatureFlag(jobj, segments, cdi)).feature_key: ff  # pylint: disable=C0103
+            for jobj in configuration.get("featureFlags") or []
+        }
+
     # pylint: disable=R0913
     def __init__(
         self,
         environment: Optional[str],
+        last_modified: Optional[str],
         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, holdout: %s)',
-            environment, settings, feature_flags, custom_data_info, holdout
+            "CALL: DataFile(environment: %s, last_modified: %s, settings: %s, feature_flags: %s,"
+            " custom_data_info: %s, holdout: %s)",
+            environment, last_modified, settings, feature_flags, custom_data_info, holdout
         )
         self.__environment = environment  # pylint: disable=W0238
+        self.__last_modified = last_modified
         self.__settings = settings
         self.__feature_flags: Dict[str, FeatureFlag] = feature_flags
         self.__me_groups = self.__make_me_groups(feature_flags.values())
@@ -69,10 +87,16 @@ class DataFile:
         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, holdout: %s)',
-            environment, settings, feature_flags, custom_data_info
+            "RETURN: DataFile(environment: %s, last_modified: %s, settings: %s, feature_flags: %s,"
+            " custom_data_info: %s, holdout: %s)",
+            environment, last_modified, settings, feature_flags, custom_data_info, holdout
         )
 
+    @property
+    def last_modified(self) -> Optional[str]:
+        """Returns last modified string"""
+        return self.__last_modified
+
     @property
     def settings(self) -> Settings:
         """Returns settings"""
@@ -177,11 +201,12 @@ class DataFile:
 
     def __str__(self):
         return (
-            f"DataFile{{"
+            "DataFile{"
             f"environment:'{self.__environment}',"
+            f"last_modified:'{self.__last_modified}',"
             f"feature_flags:{len(self.__feature_flags)},"
             f"settings:{self.__settings}"
-            f"}}"
+            "}"
         )
 
     class RuleInfo:

{kameleoon-client-python-3.12.1 → kameleoon-client-python-3.14.0}/kameleoon/configuration/feature_flag.py

@@ -2,9 +2,11 @@
 
 from typing import Any, List, Dict, Optional
 
+from kameleoon.configuration.custom_data_info import CustomDataInfo
 from kameleoon.configuration.rule import Rule
 from kameleoon.configuration.variation import Variation
 from kameleoon.helpers.string_utils import StringUtils
+from kameleoon.targeting.models import Segment
 
 
 class FeatureFlag:
@@ -12,12 +14,7 @@ class FeatureFlag:
     FeatureFlag is used for operating feature flags with rules
     """
 
-    @staticmethod
-    def from_array(array: List[Dict[str, Any]]) -> List["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]) -> None:
+    def __init__(self, dict_json: Dict[str, Any], segments: Dict[int, Segment], cdi: CustomDataInfo) -> 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", "")
@@ -26,7 +23,9 @@ class FeatureFlag:
             dict_json.get("variations", [])
         )
         self.environment_enabled = dict_json.get("environmentEnabled", False)
-        self.rules: List[Rule] = Rule.from_array(dict_json.get("rules", []))
+        self.rules: List[Rule] = Rule.from_array(dict_json.get("rules", []), segments)
+        bucketing_cd_id = dict_json.get("bucketingCustomDataId")
+        self.bucketing_custom_data_index = cdi.get_custom_data_index_by_id(bucketing_cd_id) if bucketing_cd_id else None
 
     def get_variation(self, key: str) -> Optional[Variation]:
         """Retrun a variation for the given key"""
@@ -41,6 +40,7 @@ class FeatureFlag:
             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"rules:{len(self.rules)},"
+            f"bucketing_custom_data_index:{self.bucketing_custom_data_index}"
             f"}}"
         )

{kameleoon-client-python-3.12.1 → kameleoon-client-python-3.14.0}/kameleoon/configuration/rule.py

@@ -12,12 +12,11 @@ class Rule:
     """
 
     @staticmethod
-    def from_array(array: List[Dict[str, Any]]) -> List["Rule"]:
+    def from_array(array: List[Dict[str, Any]], segments: Dict[int, Segment]) -> List["Rule"]:
         """Create a list of Rules from the json array"""
+        return [Rule(item, segments) for item in array]
 
-        return [Rule(item) for item in array]
-
-    def __init__(self, dict_json: Dict[str, Any]):
+    def __init__(self, dict_json: Dict[str, Any], segments: Dict[int, Segment]) -> None:
         self.id_: int = dict_json["id"]
         self.order: int = dict_json.get("order", 0)
         type_literal: str = dict_json.get("type", "")
@@ -25,21 +24,19 @@ class Rule:
         self.exposition: float = dict_json.get("exposition", 0.0)
         self.experiment = Experiment.from_json(dict_json)
         self.respool_time: Optional[int] = dict_json.get("respoolTime", 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
+        segment_id = dict_json.get("segmentId")
+        self.segment_id: int = segment_id or -1
+        self.targeting_segment: Optional[Segment] = segments.get(segment_id) if segment_id else None
 
     @property
     def is_experimentation(self) -> bool:
         """Return `true` if rule is `experimentation` type"""
-
         return self.type == RuleType.EXPERIMENTATION
 
     @property
     def is_targeted_delivery(self) -> bool:
         """Return `true` if rule is `targeted delivery` type"""
-
         return self.type == RuleType.TARGETED_DELIVERY
 
-    def __str__(self):
+    def __str__(self) -> str:
         return f"Rule{{id:{self.id_}}}"

{kameleoon-client-python-3.12.1 → kameleoon-client-python-3.14.0}/kameleoon/data/manager/visitor.py

@@ -1,4 +1,6 @@
 """Visitor"""
+import time
+
 from threading import Lock
 from typing import Any, Callable, Optional, Dict, List, Iterator, Iterable, cast
 
@@ -44,6 +46,11 @@ class Visitor:  # pylint: disable=R0904
         """Creates and returns a clone of the current Visitor instance which shares all the visitor data."""
         return Visitor(self)
 
+    @property
+    def time_started(self) -> int:
+        """Returns the current visit's start time"""
+        return self._data.time_started
+
     def enumerate_sendable_data(self) -> Iterator[Sendable]:
         """Enumerates all sendable data associated with this Visitor."""
         KameleoonLogger.debug('CALL: Visitor.enumerate_sendable_data()')
@@ -263,6 +270,7 @@ class Visitor:  # pylint: disable=R0904
     class VisitorData:
         """Visitor Data"""
         def __init__(self) -> None:
+            self.time_started = int(time.time() * 1000)
             self.lock = Lock()
             self.user_agent: Optional[str] = None
             self.device: Optional[Device] = None
@@ -293,6 +301,8 @@ class Visitor:  # pylint: disable=R0904
                 yield self.operating_system
             if self.geolocation:
                 yield self.geolocation
+            if self.visitor_visits:
+                yield self.visitor_visits
             if self.custom_data_dict is not None:
                 yield from list(self.custom_data_dict.values())
             if self.page_view_visits is not None:
@@ -309,18 +319,20 @@ class Visitor:  # pylint: disable=R0904
                 count += 1
             if self.browser is not None:
                 count += 1
+            if self.operating_system is not None:
+                count += 1
             if self.geolocation is not None:
                 count += 1
-            if self.operating_system is not None:
+            if self.visitor_visits:
                 count += 1
             if self.custom_data_dict is not None:
                 count += len(self.custom_data_dict)
             if self.page_view_visits is not None:
                 count += len(self.page_view_visits)
-            if self.conversions is not None:
-                count += len(self.conversions)
             if self.variations is not None:
                 count += len(self.variations)
+            if self.conversions is not None:
+                count += len(self.conversions)
             return count
 
     class DataAddingContext:
@@ -433,7 +445,8 @@ class Visitor:  # pylint: disable=R0904
             self._data.cbscores = cast(CBScores, context.data)
 
     def _set_visitor_visits(self, context: DataAddingContext) -> None:
-        self._data.visitor_visits = cast(VisitorVisits, context.data)
+        if context.overwrite or (self._data.visitor_visits is None):
+            self._data.visitor_visits = cast(VisitorVisits, context.data).localize(self._data.time_started)
 
     def _set_is_unique_identifier(self, context: DataAddingContext) -> None:
         self._is_unique_identifier = cast(UniqueIdentifier, context.data).value

kameleoon-client-python-3.14.0/kameleoon/data/visitor_visits.py

@@ -0,0 +1,117 @@
+"""Visitor visits"""
+
+from typing import Any, List, Optional, Tuple
+
+from kameleoon.data import DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
+from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
+
+from kameleoon.data.data import BaseData
+
+
+class VisitorVisits(BaseData, DuplicationUnsafeSendableBase):
+    """Visitor visits"""
+
+    EVENT_TYPE = "staticData"
+
+    def __init__(
+        self, prev_visits: List["Visit"], visit_number=0, *, time_started=0, time_since_previous_visit=0
+    ) -> None:
+        super().__init__()
+        self.__visit_number = max(visit_number, len(prev_visits))
+        self.__prev_visits = prev_visits
+        self.__time_started = time_started
+        self.__time_since_previous_visit = time_since_previous_visit
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.VISITOR_VISITS
+
+    @property
+    def visit_number(self) -> int:
+        """Returns the visit number"""
+        return self.__visit_number
+
+    @property
+    def prev_visits(self) -> List["Visit"]:
+        """Returns the previous visit list"""
+        return self.__prev_visits
+
+    @property
+    def time_started(self) -> int:
+        """Returns the current visit's start time"""
+        return self.__time_started
+
+    @property
+    def time_since_previous_visit(self) -> int:
+        """Returns the time since the previous visit"""
+        return self.__time_since_previous_visit
+
+    def localize(self, time_started: int) -> "VisitorVisits":
+        """
+        Localizes a remote instance of `VisitorVisits` creating a new instance
+        with a specific current visit's start time.
+        """
+        time_since_previous_visit = 0
+        for visit in self.__prev_visits:
+            time_delta = time_started - visit.time_last_activity
+            if time_delta >= 0:
+                time_since_previous_visit = time_delta
+                break
+        return VisitorVisits(
+            self.__prev_visits, self.__visit_number,
+            time_started=time_started, time_since_previous_visit=time_since_previous_visit,
+        )
+
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        query_builder.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+            QueryParam(QueryParams.VISIT_NUMBER, str(self.__visit_number)),
+            QueryParam(QueryParams.TIME_SINCE_PREVIOUS_VISIT, str(self.__time_since_previous_visit)),
+        )
+
+    def __eq__(self, value: Any) -> bool:
+        return isinstance(value, VisitorVisits) and (self.__visit_number == value.visit_number) and \
+            (self.__prev_visits == value.prev_visits) and (self.__time_started == value.time_started) and \
+            (self.__time_since_previous_visit == value.time_since_previous_visit)
+
+    def __str__(self) -> str:
+        return (
+            "VisitorVisits{"
+            f"visit_number:{self.__visit_number},"
+            f"prev_visits:{[str(v) for v in self.__prev_visits]},"
+            f"time_started:{self.__time_started},"
+            f"time_since_previous_visit:{self.__time_since_previous_visit}"
+            "}"
+        )
+
+    @staticmethod
+    def get_visitor_visits(obj: Any) -> Tuple["VisitorVisits", bool]:
+        """Determines if an object is `VisitorVisits` or `None` and returns a valid instance of `VisitorVisits`."""
+        if isinstance(obj, VisitorVisits):
+            return obj, True
+        return VisitorVisits([]), obj is None
+
+    class Visit:
+        """Visit"""
+
+        def __init__(self, time_started: int, time_last_activity: Optional[int] = None) -> None:
+            self.__time_started = time_started
+            self.__time_last_activity = time_last_activity or time_started
+
+        @property
+        def time_started(self) -> int:
+            """Returns the start time"""
+            return self.__time_started
+
+        @property
+        def time_last_activity(self) -> int:
+            """Returns the last activity time"""
+            return self.__time_last_activity
+
+        def __eq__(self, value: Any) -> bool:
+            return isinstance(value, VisitorVisits.Visit) and (self.__time_started == value.time_started) and \
+                (self.__time_last_activity == value.time_last_activity)
+
+        def __str__(self) -> str:
+            return f"Visit{{time_started:{self.__time_started},time_last_activity:{self.__time_last_activity}}}"

{kameleoon-client-python-3.12.1 → kameleoon-client-python-3.14.0}/kameleoon/kameleoon_client.py

@@ -47,7 +47,7 @@ from kameleoon.network.net_provider_impl import NetProviderImpl
 from kameleoon.network.network_manager_factory import NetworkManagerFactory
 from kameleoon.network.network_manager_factory_impl import NetworkManagerFactoryImpl
 from kameleoon.network.sendable import Sendable
-from kameleoon.network.services.configuration_service import ConfigurationService
+from kameleoon.network.services.configuration_service import ConfigurationService, FetchedConfiguration
 from kameleoon.network.cookie.cookie_manager import CookieManager
 
 from kameleoon.real_time.real_time_configuration_service import RealTimeConfigurationService
@@ -674,7 +674,7 @@ class KameleoonClient:
         if forced_variation:
             eval_exp = EvaluatedExperiment.from_forced_variation(forced_variation)
         elif self.__is_visitor_not_in_holdout(
-            visitor, visitor_code, track, save
+            visitor, visitor_code, track, save, feature_flag.bucketing_custom_data_index
         ) and self.__is_ff_unrestricted_by_me_group(visitor, visitor_code, feature_flag):
             eval_exp = self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
         if save and not (forced_variation and forced_variation.simulated):
@@ -703,7 +703,7 @@ class KameleoonClient:
         unrestricted = True
         me_group = self._data_manager.data_file.me_groups.get(feature_flag.me_group_name)
         if me_group:
-            code_for_hash = self.__get_code_for_hash(visitor, visitor_code)
+            code_for_hash = self.__get_code_for_hash(visitor, visitor_code, feature_flag.bucketing_custom_data_index)
             me_group_hash = Hasher.obtain_hash_for_me_group(code_for_hash, feature_flag.me_group_name)
             KameleoonLogger.debug(
                 "Calculated ME group hash %s for code: %s, meGroup: %s",
@@ -722,20 +722,18 @@ class KameleoonClient:
         return unrestricted
 
     def __is_visitor_not_in_holdout(
-        self, visitor: Optional[Visitor], visitor_code: str, track: bool, save: bool
+        self, visitor: Optional[Visitor], visitor_code: str, track: bool, save: bool, bucketing_cd_index: Optional[int]
     ) -> bool:
         holdout = self._data_manager.data_file.holdout
         if holdout is None:
             return True
         in_holdout_variation_key = "in-holdout"
         KameleoonLogger.debug(
-            "CALL: KameleoonClient.__is_visitor_not_in_holdout(visitor, visitor_code: %s, track: %s, save: %s)",
-            visitor_code,
-            track,
-            save,
+            "CALL: KameleoonClient.__is_visitor_not_in_holdout(visitor, visitor_code: %s, track: %s, save: %s, "
+            "bucketing_cd_index: %s)", visitor_code, track, save, bucketing_cd_index
         )
         is_not_in_holdout = True
-        code_for_hash = self.__get_code_for_hash(visitor, visitor_code)
+        code_for_hash = self.__get_code_for_hash(visitor, visitor_code, bucketing_cd_index)
         variation_hash = Hasher.obtain(code_for_hash, holdout.id_)
         KameleoonLogger.debug("Calculated holdout hash %s for code %s", variation_hash, code_for_hash)
         var_by_exp = holdout.get_variation(variation_hash)
@@ -745,12 +743,9 @@ class KameleoonClient:
                 eval_exp = EvaluatedExperiment(var_by_exp, holdout, RuleType.EXPERIMENTATION)
                 self.__save_variation(visitor_code, eval_exp)
         KameleoonLogger.debug(
-            "RETURN: KameleoonClient.__is_visitor_not_in_holdout(visitor, visitor_code: %s, track: %s, save: %s)"
-            " -> (is_not_in_holdout: %s)",
-            visitor_code,
-            track,
-            save,
-            is_not_in_holdout,
+            "RETURN: KameleoonClient.__is_visitor_not_in_holdout(visitor, visitor_code: %s, track: %s, save: %s, "
+            "bucketing_cd_index: %s) -> (is_not_in_holdout: %s)",
+            visitor_code, track, save, bucketing_cd_index, is_not_in_holdout
         )
         return is_not_in_holdout
 
@@ -1435,13 +1430,18 @@ class KameleoonClient:
         KameleoonLogger.debug("CALL: KameleoonClient._fetch_configuration(time_stamp: %s)", time_stamp)
         success = False
         try:
-            configuration_json = await self._obtain_configuration(time_stamp)
-            if configuration_json:
-                data_file = DataFile.from_json(self._config.environment, configuration_json)
-                self._data_manager.data_file = data_file
-                self._network_manager.url_provider.apply_data_api_domain(data_file.settings.data_api_domain)
-                self._call_update_handler_if_needed(time_stamp is not None)
-            success = True
+            fetched_configuration = await self._obtain_configuration(time_stamp)
+            if fetched_configuration:
+                if fetched_configuration.configuration:
+                    data_file = DataFile.from_json(
+                        self._config.environment,
+                        fetched_configuration.last_modified,
+                        fetched_configuration.configuration
+                    )
+                    self._data_manager.data_file = data_file
+                    self._network_manager.url_provider.apply_data_api_domain(data_file.settings.data_api_domain)
+                    self._call_update_handler_if_needed(time_stamp is not None)
+                success = True
         except Exception as ex:
             KameleoonLogger.error("Error occurred during configuration fetching: %s", ex)
         self._manage_configuration_update(self._data_manager.data_file.settings.real_time_update)
@@ -1532,7 +1532,7 @@ class KameleoonClient:
         if not self._data_manager.data_file.settings.real_time_update:
             await self._fetch_configuration()
 
-    async def _obtain_configuration(self, time_stamp: Optional[int]) -> Optional[Dict[str, Any]]:
+    async def _obtain_configuration(self, time_stamp: Optional[int]) -> Optional[FetchedConfiguration]:
         """
         Obtaining configuration from CDN service.
         Should be run in a separate thead.
@@ -1541,15 +1541,14 @@ class KameleoonClient:
         :return: None
         """
         KameleoonLogger.debug("CALL: KameleoonClient._obtain_configuration(time_stamp: %s)", time_stamp)
+        last_modified = self._data_manager.data_file.last_modified
         service: ConfigurationService = self._network_manager.get_service(ConfigurationService)
-        response = await service.fetch_configuration(self._config.environment, time_stamp)
-        content = None
-        if response.code and (response.code // 100 == 2):
-            content = response.content
+        fetched_configuration = await service.fetch_configuration(self._config.environment, time_stamp, last_modified)
         KameleoonLogger.debug(
-            "RETURN: KameleoonClient._obtain_configuration(time_stamp: %s) -> (content: %s)", time_stamp, content
+            "RETURN: KameleoonClient._obtain_configuration(time_stamp: %s) -> (fetched_configuration: %s)",
+            time_stamp, fetched_configuration
         )
-        return content
+        return fetched_configuration
 
     def __get_feature_variation_key(self, visitor_code: str, feature_key: str) -> Tuple[FeatureFlag, str]:
         """
@@ -1597,21 +1596,25 @@ class KameleoonClient:
         )
 
     @staticmethod
-    def __get_code_for_hash(visitor: Optional[Visitor], visitor_code: str) -> str:
-        # use mapping_identifier instead of visitor_code if it was set up
-        return (
-            visitor.mapping_identifier
-            if visitor is not None and visitor.mapping_identifier is not None
-            else visitor_code
-        )
+    def __get_code_for_hash(visitor: Optional[Visitor], visitor_code: str, bucketing_cd_index: Optional[int]) -> str:
+        if visitor is None:
+            return visitor_code
+        # 1. Try to use the bucketing custom data's value if bucketingCustomDataId is defined
+        if bucketing_cd_index:
+            bucketing_custom_data = visitor.custom_data.get(bucketing_cd_index)
+            if bucketing_custom_data and (len(bucketing_custom_data.values) > 0):
+                return bucketing_custom_data.values[0]
+        # 2. Use mappingIdentifier instead of visitorCode if it was set up
+        return visitor.mapping_identifier or visitor_code
 
     def __evaluate_cbscores(
-        self, visitor: Optional[Visitor], visitor_code: str, rule: Rule
+        self, visitor: Optional[Visitor], visitor_code: str, rule: Rule, bucketing_cd_index: Optional[int]
     ) -> Optional[EvaluatedExperiment]:
         if (visitor is None) or (visitor.cbscores is None):
             return None
         KameleoonLogger.debug(
-            "CALL: KameleoonClient.__evaluate_cbscores(visitor, visitor_code: %s, rule: %s)", visitor_code, rule
+            "CALL: KameleoonClient.__evaluate_cbscores(visitor, visitor_code: %s, rule: %s, bucketing_cd_index: %s)",
+            visitor_code, rule, bucketing_cd_index
         )
         eval_exp = None
         var_id_group_by_scores = visitor.cbscores.values.get(rule.experiment.id_)
@@ -1629,16 +1632,14 @@ class KameleoonClient:
                 size = len(var_by_exp_in_cbs)
                 idx = 0
                 if size > 1:
-                    code_for_hash = self.__get_code_for_hash(visitor, visitor_code)
+                    code_for_hash = self.__get_code_for_hash(visitor, visitor_code, bucketing_cd_index)
                     variation_hash = Hasher.obtain(code_for_hash, rule.experiment.id_, rule.respool_time)
                     KameleoonLogger.debug("Calculated CBS hash %s for code %s", variation_hash, code_for_hash)
                     idx = min(int(variation_hash * size), size - 1)
                 eval_exp = EvaluatedExperiment.from_var_by_exp_rule(var_by_exp_in_cbs[idx], rule)
         KameleoonLogger.debug(
-            "RETURN: KameleoonClient.__evaluate_cbscores(visitor, visitor_code: %s, rule: %s) -> (eval_exp: %s)",
-            visitor_code,
-            rule,
-            eval_exp,
+            "RETURN: KameleoonClient.__evaluate_cbscores(visitor, visitor_code: %s, rule: %s, bucketing_cd_index: %s)"
+            " -> (eval_exp: %s)", visitor_code, rule, bucketing_cd_index, eval_exp
         )
         return eval_exp
 
@@ -1652,7 +1653,7 @@ class KameleoonClient:
             feature_flag,
         )
         visitor = self._visitor_manager.get_visitor(visitor_code)
-        code_for_hash = self.__get_code_for_hash(visitor, visitor_code)
+        code_for_hash = self.__get_code_for_hash(visitor, visitor_code, feature_flag.bucketing_custom_data_index)
         eval_exp = None
         for rule in feature_flag.rules:
             forced_variation = visitor.get_forced_experiment_variation(rule.experiment.id_) if visitor else None
@@ -1672,7 +1673,9 @@ class KameleoonClient:
             KameleoonLogger.debug("Calculated rule hash %s for code %s", hash_rule, code_for_hash)
             # check main expostion for rule with hashRule
             if hash_rule <= rule.exposition:
-                eval_exp = self.__evaluate_cbscores(visitor, visitor_code, rule)
+                eval_exp = self.__evaluate_cbscores(
+                    visitor, visitor_code, rule, feature_flag.bucketing_custom_data_index
+                )
                 if eval_exp:
                     break
                 if rule.is_targeted_delivery:

{kameleoon-client-python-3.12.1 → kameleoon-client-python-3.14.0}/kameleoon/managers/remote_data/remote_data_manager.py

@@ -63,7 +63,7 @@ class RemoteDataManager:
         if response.content is None:
             return []
         custom_data_info = self._data_manager.data_file.custom_data_info
-        remote_visitor_data = RemoteDataManager.__parse_remote_visitor_data(response.content)
+        remote_visitor_data = RemoteDataManager.__parse_remote_visitor_data(response.content, data_filter)
         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:
@@ -77,9 +77,9 @@ class RemoteDataManager:
         return remote_visitor_data.collect_data_to_return()
 
     @staticmethod
-    def __parse_remote_visitor_data(raw: Any) -> RemoteVisitorData:
+    def __parse_remote_visitor_data(raw: Any, data_filter: RemoteVisitorDataFilter) -> RemoteVisitorData:
         try:
-            return RemoteVisitorData(raw)
+            return RemoteVisitorData(raw, data_filter)
         except Exception as ex:  # pylint: disable=W0703
             KameleoonLogger.error("Parsing of remote visitor data failed: %s", ex)
-            return RemoteVisitorData({})
+            return RemoteVisitorData({}, data_filter)