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

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

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

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

@@ -1,6 +1,11 @@
 # pylint: disable=duplicate-code
 """Conversion data"""
+
+import json
+from typing import Optional, Iterable
+from kameleoon.data.custom_data import CustomData
 from kameleoon.data.data import Data, DataType
+from kameleoon.helpers.string_utils import StringUtils
 from kameleoon.network.sendable import DuplicationSafeSendableBase
 from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
 
@@ -11,7 +16,13 @@ class Conversion(Data, DuplicationSafeSendableBase):
 
     EVENT_TYPE = "conversion"
 
-    def __init__(self, goal_id: int, revenue: float = 0.0, negative: bool = False) -> None:
+    def __init__(
+        self,
+        goal_id: int,
+        revenue: float = 0.0,
+        negative: bool = False,
+        metadata: Optional[Iterable[CustomData]] = None,
+    ) -> None:
         """
         :param goal_id: Id of the goal associated to the conversion
         :type goal_id: int
@@ -19,6 +30,8 @@ class Conversion(Data, DuplicationSafeSendableBase):
         :type revenue: float
         :param negative: Optional field - If the revenue is negative. By default it's positive, defaults to False
         :type negative: bool
+        :param metadata: Optional field - Metadata of the conversion. `None` by default.
+        :type metadata: Optional[Iterable[CustomData]]
 
         Example:
 
@@ -31,6 +44,7 @@ class Conversion(Data, DuplicationSafeSendableBase):
         self.__goal_id = goal_id
         self.__revenue = revenue
         self.__negative = negative
+        self.__metadata = metadata
 
     @property
     def goal_id(self) -> int:
@@ -47,6 +61,11 @@ class Conversion(Data, DuplicationSafeSendableBase):
         """Returns negative flag state"""
         return self.__negative
 
+    @property
+    def metadata(self) -> Optional[Iterable[CustomData]]:
+        """Returns metadata"""
+        return self.__metadata
+
     @property
     def data_type(self) -> DataType:
         return DataType.CONVERSION
@@ -60,10 +79,23 @@ class Conversion(Data, DuplicationSafeSendableBase):
             QueryParam(QueryParams.REVENUE, str(self.revenue)),
             QueryParam(QueryParams.NEGATIVE, "true" if self.negative else "false"),
         )
+        if self.metadata:
+            query_builder.append(QueryParam(QueryParams.METADATA, self.__encode_metadata()))
+
+    def __encode_metadata(self) -> str:
+        metadata = {}
+        if self.metadata is not None:
+            added_indices = set()
+            for mcd in self.metadata:
+                if isinstance(mcd, CustomData) and (mcd.id not in added_indices):
+                    metadata[mcd.id] = mcd.values
+                    added_indices.add(mcd.id)
+        return json.dumps(metadata, separators=(",", ":"))
 
     def __str__(self):
         return (
             f"Conversion{{goal_id:{self.__goal_id},"
             f"revenue:{self.__revenue},"
-            f"negative:{self.__negative}}}"
+            f"negative:{self.__negative},"
+            f"metadata:{StringUtils.object_to_string(self.__metadata)}}}"
         )

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

@@ -45,9 +45,6 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
     def data_type(self) -> DataType:
         return DataType.CUSTOM_DATA
 
-    def encode_query(self) -> str:
-        return super().encode_query() if len(self.__values) > 0 else ""
-
     def _add_query_params(self, query_builder: QueryBuilder) -> None:
         str_values = json.dumps({v: 1 for v in self.__values}, separators=(",", ":"))
         query_builder.extend(
@@ -58,7 +55,4 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
         )
 
     def __str__(self):
-        return (
-            f"CustomData{{id:{self.__id},"
-            f"values:{self.__values}}}"
-        )
+        return f"CustomData{{id:{self.__id},values:{self.__values}}}"

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

@@ -23,6 +23,7 @@ class DataType(IntEnum):
     FORCED_EXPERIMENT_VARIATION = 14
     FORCED_FEATURE_VARIATION = 15
     CBS = 16
+    PERSONALIZATION = 17
 
 
 class BaseData:

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

@@ -15,6 +15,7 @@ from kameleoon.data.kcs_heat import KcsHeat
 from kameleoon.data.mapping_identifier import MappingIdentifier
 from kameleoon.data.operating_system import OperatingSystem
 from kameleoon.data.page_view import PageView
+from kameleoon.data.personalization import Personalization
 from kameleoon.data.unique_identifier import UniqueIdentifier
 from kameleoon.data.user_agent import UserAgent
 from kameleoon.data.manager.assigned_variation import AssignedVariation
@@ -127,6 +128,13 @@ class Visitor:  # pylint: disable=R0904
         KameleoonLogger.debug('CALL/RETURN: Visitor.variations -> (variations: %s)', variations)
         return variations
 
+    @property
+    def personalizations(self) -> Dict[int, Personalization]:
+        """Returns the personalizations associated with this Visitor."""
+        personalizations = EMPTY_DICT if self._data.personalizations is None else self._data.personalizations.copy()
+        KameleoonLogger.debug('CALL/RETURN: Visitor.personalizations -> (personalizations: %s)', personalizations)
+        return personalizations
+
     def get_forced_feature_variation(self, feature_key: str) -> Optional[ForcedFeatureVariation]:
         """
         Returns an associated forced feature variation by its feature key if it is present.
@@ -266,6 +274,7 @@ class Visitor:  # pylint: disable=R0904
             self.page_view_visits: Optional[Dict[str, PageViewVisit]] = None
             self.conversions: Optional[List[Conversion]] = None
             self.variations: Optional[Dict[int, AssignedVariation]] = None
+            self.personalizations: Optional[Dict[int, Personalization]] = None
             self.forced_variations: Optional[Dict[int, ForcedExperimentVariation]] = None
             self.simulated_variations: Optional[Dict[str, ForcedFeatureVariation]] = None
             self.kcs_heat: Optional[KcsHeat] = None
@@ -343,9 +352,16 @@ class Visitor:  # pylint: disable=R0904
         variation = cast(AssignedVariation, context.data)
         if self._data.variations is None:
             self._data.variations = {}
-        if context.overwrite or variation.experiment_id not in self.variations:
+        if context.overwrite or variation.experiment_id not in self._data.variations:
             self._data.variations[variation.experiment_id] = variation
 
+    def _add_personalization(self, context: DataAddingContext) -> None:
+        personalization = cast(Personalization, context.data)
+        if self._data.personalizations is None:
+            self._data.personalizations = {}
+        if context.overwrite or personalization.id not in self._data.personalizations:
+            self._data.personalizations[personalization.id] = personalization
+
     def _add_forced_feature_variation(self, context: DataAddingContext) -> None:
         ffv = cast(ForcedFeatureVariation, context.data)
         if self._data.simulated_variations is None:
@@ -441,6 +457,7 @@ class Visitor:  # pylint: disable=R0904
         CBScores: _set_cbscores,
         VisitorVisits: _set_visitor_visits,
         AssignedVariation: _add_variation,
+        Personalization: _add_personalization,
         ForcedFeatureVariation: _add_forced_feature_variation,
         ForcedExperimentVariation: _add_forced_experiment_variation,
         UniqueIdentifier: _set_is_unique_identifier,

kameleoon-client-python-3.12.0/kameleoon/data/personalization.py

@@ -0,0 +1,30 @@
+"""Personalization"""
+
+from kameleoon.data import DataType
+from kameleoon.data.data import BaseData
+
+
+class Personalization(BaseData):
+    """Personalization"""
+
+    def __init__(self, id_: int, variation_id: int) -> None:
+        super().__init__()
+        self.__id = id_
+        self.__variation_id = variation_id
+
+    @property
+    def id(self) -> int:  # pylint: disable=C0103
+        """Returns personalization ID"""
+        return self.__id
+
+    @property
+    def variation_id(self) -> int:
+        """Returns variation ID"""
+        return self.__variation_id
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.PERSONALIZATION
+
+    def __str__(self):
+        return f"Personalization{{id:{self.__id},variation_id:{self.__variation_id}}}"

kameleoon-client-python-3.12.0/kameleoon/helpers/domain.py

@@ -0,0 +1,83 @@
+"""Helper for domain"""
+import re
+from typing import Optional
+
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+
+HTTP = "http://"
+HTTPS = "https://"
+REGEX_DOMAIN = (
+    r"^(\.?(([a-zA-Z\d][a-zA-Z\d-]*[a-zA-Z\d])|[a-zA-Z\d]))"
+    r"(\.(([a-zA-Z\d][a-zA-Z\d-]*[a-zA-Z\d])|[a-zA-Z\d])){1,126}$"
+)
+LOCALHOST = "localhost"
+
+
+def validate_top_level_domain(top_level_domain: str) -> str:
+    """
+    Validate the given top-level domain.
+
+    Args:
+        top_level_domain (str): The top-level domain to validate.
+
+    Returns:
+        str: The validated top-level domain.
+    """
+    if top_level_domain == "":
+        return top_level_domain
+
+    top_level_domain = check_and_trim_protocol(top_level_domain.lower())
+
+    if not re.match(REGEX_DOMAIN, top_level_domain) and top_level_domain != LOCALHOST:
+        KameleoonLogger.error(
+            f"The top-level domain '{top_level_domain}' is invalid. The value has been set as provided, but it does "
+            f"not meet the required format for proper SDK functionality. Please check the domain for correctness.")
+        return top_level_domain
+
+    return top_level_domain
+
+
+def validate_network_domain(network_domain: Optional[str]) -> Optional[str]:
+    """
+    Validate the given network domain.
+
+    Args:
+        network_domain: The network domain to validate.
+
+    Returns:
+        str or None: The validated network domain, or None if invalid.
+    """
+    if not network_domain:
+        return None
+
+    network_domain = check_and_trim_protocol(network_domain.lower())
+
+    # Replace first and last dot
+    network_domain = re.sub(r"^\.+|\.+$", "", network_domain)
+
+    if not re.match(REGEX_DOMAIN, network_domain) and network_domain != LOCALHOST:
+        KameleoonLogger.error(f"The network domain '{network_domain}' is invalid.")
+        return None
+
+    return network_domain
+
+
+def check_and_trim_protocol(domain: str) -> str:
+    """
+    Check if the domain contains a protocol and trim it if it does.
+
+    Args:
+        domain: The domain to check and trim.
+
+    Returns:
+        str: The domain after trimming the protocol.
+    """
+    protocols = [HTTP, HTTPS]
+    for protocol in protocols:
+        if domain.startswith(protocol):
+            domain = domain[len(protocol):]
+            KameleoonLogger.warning(
+                f"The domain contains '{protocol}'. Domain after protocol trimming: '{domain}'"
+            )
+            return domain
+    return domain

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.12.0}/kameleoon/helpers/string_utils.py

@@ -1,5 +1,6 @@
 """Helper class for work with string values"""
 
+import collections.abc
 from typing import Any, Optional
 
 
@@ -31,6 +32,8 @@ class StringUtils:
     @staticmethod
     def object_to_string(data: Any) -> str:
         """Convert various data types into their string representation."""
+        if data is None:
+            return "None"
         if isinstance(data, str):
             return f"'{data}'"
         result = StringUtils._collection_to_string(data)
@@ -38,19 +41,17 @@ class StringUtils:
             return result
         if isinstance(data, bool):
             return StringUtils.bool_to_string_lower_case(data)
-        if data is None:
-            return "None"
         if hasattr(data, '__str__'):
             return str(data)
         return repr(data)
 
     @staticmethod
     def _collection_to_string(data: Any) -> Optional[str]:
-        if isinstance(data, (list, tuple)):
-            return "[" + ",".join(StringUtils.object_to_string(item) for item in data) + "]"
         if isinstance(data, dict):
             return "{" + ",".join(
                 f"{StringUtils.object_to_string(key)}: {StringUtils.object_to_string(value)}"
                 for key, value in data.items()
             ) + "}"
+        if isinstance(data, collections.abc.Iterable):
+            return "[" + ",".join(StringUtils.object_to_string(item) for item in data) + "]"
         return None

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.12.0}/kameleoon/kameleoon_client.py

@@ -142,6 +142,7 @@ class KameleoonClient:
             config.default_timeout_second,
             NetProviderImpl(),
             atsf,
+            config.network_domain,
         )
         self._targeting_manager = TargetingManager(self._data_manager, self._visitor_manager)
         self._warehouse_manager = WarehouseManager(self._network_manager, self._visitor_manager)
@@ -354,7 +355,8 @@ class KameleoonClient:
         KameleoonLogger.info("RETURN: KameleoonClient.add_data(visitor_code: %s, args: %s)", visitor_code, args)
 
     def track_conversion(
-        self, visitor_code: str, goal_id: int, revenue: float = 0.0, is_unique_identifier: Optional[bool] = None
+        self, visitor_code: str, goal_id: int, revenue: float = 0.0, is_unique_identifier: Optional[bool] = None,
+        negative=False, metadata: Optional[Iterable[CustomData]] = None,
     ) -> None:
         """
         To track conversion, use the track_conversion() method. This method requires visitor_code and goal_id to track
@@ -372,28 +374,25 @@ class KameleoonClient:
         :param is_unique_identifier: (Deprecated) Parameter that specifies whether the visitorCode is
         a unique identifier.
         :type is_unique_identifier: Optional[bool]
-        :return: None
+        :param negative: Defines if the revenue is positive or negative. This field is optional (`False` by default).
+        :type negative: bool
+        :param metadata: Metadata of the conversion. This field is optional (`None` by default).
+        :type metadata: Optional[Iterable[CustomData]]
         """
         KameleoonLogger.info(
             "CALL: KameleoonClient.track_conversion(visitor_code: %s, goal_id: %s, revenue: %s, "
-            "is_unique_identifier: %s)",
-            visitor_code,
-            goal_id,
-            revenue,
-            is_unique_identifier,
+            "is_unique_identifier: %s, negative: %s, metadata: %s)",
+            visitor_code, goal_id, revenue, is_unique_identifier, negative, metadata
         )
         validate_visitor_code(visitor_code)
         if is_unique_identifier is not None:
             self.__set_unique_identifier(visitor_code, is_unique_identifier)
-        self.add_data(visitor_code, Conversion(goal_id, revenue))
+        self.add_data(visitor_code, Conversion(goal_id, revenue, negative, metadata))
         self._tracking_manager.add_visitor_code(visitor_code)
         KameleoonLogger.info(
             "RETURN: KameleoonClient.track_conversion(visitor_code: %s, goal_id: %s, revenue: %s, "
-            "is_unique_identifier: %s)",
-            visitor_code,
-            goal_id,
-            revenue,
-            is_unique_identifier,
+            "is_unique_identifier: %s, negative: %s, metadata: %s)",
+            visitor_code, goal_id, revenue, is_unique_identifier, negative, metadata
         )
 
     def flush(

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.12.0}/kameleoon/kameleoon_client_config.py

@@ -1,11 +1,12 @@
 """Kameleoon Client Configuration"""
+
 import logging
 import os
 from typing import Any, Dict, Optional
 import yaml
 
 from kameleoon.exceptions import ConfigCredentialsInvalid, ConfigFileNotFound
-from kameleoon.helpers.domain import validate_top_level_domain
+from kameleoon.helpers.domain import validate_top_level_domain, validate_network_domain
 from kameleoon.helpers.logger import Logger
 from kameleoon.helpers.string_utils import StringUtils
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
@@ -22,7 +23,7 @@ DEFAULT_CONFIGURATION_PATH = "/etc/kameleoon/client-python.yaml"
 class KameleoonClientConfig:
     """Client configuration which can be used instead of external configuration file"""
 
-    # pylint: disable=R0913
+    # pylint: disable=R0913, R0904
     def __init__(
         self,
         client_id: str,
@@ -35,6 +36,7 @@ class KameleoonClientConfig:
         logger: Optional[logging.Logger] = None,
         multi_threading: Optional[bool] = None,
         tracking_interval_millisecond=DEFAULT_TRACKING_INTERVAL_MILLISECONDS,
+        network_domain: Optional[str] = None,
     ) -> None:
         """
         :param logger: (Deprecated)
@@ -67,6 +69,7 @@ class KameleoonClientConfig:
         self.__multi_threading = False
         if multi_threading is not None:
             self.set_multi_threading(multi_threading)
+        self.set_network_domain(network_domain)
 
     @staticmethod
     def read_from_yaml(config_path=DEFAULT_CONFIGURATION_PATH) -> "KameleoonClientConfig":
@@ -104,6 +107,8 @@ class KameleoonClientConfig:
             kwargs["top_level_domain"] = top_level_domain
         if isinstance(multi_threading := config_dict.get("multi_threading"), bool):
             kwargs["multi_threading"] = multi_threading
+        if isinstance(network_domain := config_dict.get("network_domain"), str):
+            kwargs["network_domain"] = network_domain
         return KameleoonClientConfig(client_id, client_secret, **kwargs)
 
     @property
@@ -137,9 +142,11 @@ class KameleoonClientConfig:
     def set_refresh_interval_minute(self, value: float) -> None:
         """Sets the refresh interval in minutes"""
         if value <= 0:
-            KameleoonLogger.warning("Configuration refresh interval must have positive value. "
-                                    "Default refresh interval (%s minutes) was applied.",
-                                    DEFAULT_REFRESH_INTERVAL_MINUTES)
+            KameleoonLogger.warning(
+                "Configuration refresh interval must have positive value. "
+                "Default refresh interval (%s minutes) was applied.",
+                DEFAULT_REFRESH_INTERVAL_MINUTES,
+            )
             value = DEFAULT_REFRESH_INTERVAL_MINUTES
         self.__refresh_interval_second = value * 60.0
 
@@ -151,8 +158,10 @@ class KameleoonClientConfig:
     def set_session_duration_minute(self, value: float) -> None:
         """Sets the session duration in minutes"""
         if value <= 0:
-            KameleoonLogger.warning("Session duration must have positive value. Default session duration "
-                                    "(%s minutes) was applied.", DEFAULT_SESSION_DURATION_MINUTES)
+            KameleoonLogger.warning(
+                "Session duration must have positive value. Default session duration " "(%s minutes) was applied.",
+                DEFAULT_SESSION_DURATION_MINUTES,
+            )
             value = DEFAULT_SESSION_DURATION_MINUTES
         self.__session_duration_second = value * 60.0
 
@@ -164,8 +173,10 @@ class KameleoonClientConfig:
     def set_default_timeout_millisecond(self, value: int) -> None:
         """Sets the default timeout in milliseconds"""
         if value <= 0:
-            KameleoonLogger.warning("Default timeout must have positive value. Default value (%s ms) was applied.",
-                                    DEFAULT_DEFAULT_TIMEOUT_MILLISECONDS)
+            KameleoonLogger.warning(
+                "Default timeout must have positive value. Default value (%s ms) was applied.",
+                DEFAULT_DEFAULT_TIMEOUT_MILLISECONDS,
+            )
             value = DEFAULT_DEFAULT_TIMEOUT_MILLISECONDS
         self.__default_timeout_second = value / 1000.0
 
@@ -179,12 +190,14 @@ class KameleoonClientConfig:
         if value < MIN_TRACKING_INTERVAL_MILLISECONDS:
             KameleoonLogger.warning(
                 "Tracking interval must not be shorter than (%s ms). Minimum possible interval was applied.",
-                MIN_TRACKING_INTERVAL_MILLISECONDS)
+                MIN_TRACKING_INTERVAL_MILLISECONDS,
+            )
             value = MIN_TRACKING_INTERVAL_MILLISECONDS
         elif value > MAX_TRACKING_INTERVAL_MILLISECONDS:
             KameleoonLogger.warning(
                 "Tracking interval must not be longer than (%s ms). Maximum possible interval was applied.",
-                MAX_TRACKING_INTERVAL_MILLISECONDS)
+                MAX_TRACKING_INTERVAL_MILLISECONDS,
+            )
             value = MAX_TRACKING_INTERVAL_MILLISECONDS
         self.__tracking_interval_second = value / 1000.0
 
@@ -205,8 +218,10 @@ class KameleoonClientConfig:
     def set_top_level_domain(self, value: str) -> None:
         """Sets the top level domain"""
         if not value:
-            KameleoonLogger.warning("Setting top level domain is strictly recommended, "
-                                    "otherwise you may have problems when using subdomains.")
+            KameleoonLogger.warning(
+                "Setting top level domain is strictly recommended, "
+                "otherwise you may have problems when using subdomains."
+            )
         self.__top_level_domain = validate_top_level_domain(value)
 
     @property
@@ -219,6 +234,15 @@ class KameleoonClientConfig:
         self.__multi_threading = value
         KameleoonLogger.warning("Configuration parameter 'multi_threading' is deprecated.")
 
+    @property
+    def network_domain(self) -> Optional[str]:
+        """Returns the network domain"""
+        return self.__network_domain
+
+    def set_network_domain(self, value: Optional[str]) -> None:
+        """Sets the network domain"""
+        self.__network_domain = validate_network_domain(value)
+
     def __str__(self):
         return (
             f"KameleoonClientConfig{{"
@@ -228,4 +252,6 @@ class KameleoonClientConfig:
             f"session_duration_second:{self.__session_duration_second},"
             f"environment:'{self.__environment}',"
             f"default_timeout_millisecond:{self.__default_timeout_second},"
-            f"top_level_domain:'{self.__top_level_domain}'}}")
+            f"top_level_domain:{self.__top_level_domain},"
+            f"network_domain:'{self.__network_domain}'}}"
+        )

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.12.0}/kameleoon/managers/remote_data/remote_visitor_data.py

@@ -12,6 +12,7 @@ from kameleoon.configuration.rule_type import RuleType
 from kameleoon.data.visitor_visits import VisitorVisits
 from kameleoon.data.kcs_heat import KcsHeat
 from kameleoon.data.cbscores import CBScores, ScoredVarId
+from kameleoon.data.personalization import Personalization
 from kameleoon.data.manager.assigned_variation import AssignedVariation
 from kameleoon.data.manager.page_view_visit import PageViewVisit
 from kameleoon.data import (
@@ -40,6 +41,7 @@ class RemoteVisitorData:
         self.__page_view_visits: Optional[Dict[str, PageViewVisit]] = None
         self.__custom_data_dict: Optional[Dict[int, CustomData]] = None
         self.__experiments: Optional[Dict[int, AssignedVariation]] = None
+        self.__personalizations: Optional[Dict[int, Personalization]] = None
         self.__conversions: Optional[List[Conversion]] = None
         self.__previous_visitor_visits: Optional[VisitorVisits] = None
         self.__visitor_code: Optional[str] = None
@@ -71,6 +73,8 @@ class RemoteVisitorData:
             data_to_add += self.__page_view_visits.values()
         if self.__experiments:
             data_to_add += self.__experiments.values()
+        if self.__personalizations:
+            data_to_add += self.__personalizations.values()
         if self.__conversions:
             data_to_add += self.__conversions
         data_to_add += self.__single_data()
@@ -134,6 +138,9 @@ class RemoteVisitorData:
         static_data_event = json_visit.get("staticDataEvent")
         if static_data_event:
             self.__parse_static_data(static_data_event)
+        personalization_events = json_visit.get("personalizationEvents")
+        if personalization_events:
+            self.__parse_personalizations(personalization_events)
 
     def __parse_custom_data(self, custom_data_events: List[Dict[str, Any]]) -> None:
         if self.__custom_data_dict is None:
@@ -214,17 +221,27 @@ class RemoteVisitorData:
                 if operating_system_type is not None:
                     self.__operating_system = OperatingSystem(operating_system_type)
 
-    def __single_data(self) -> List[Data]:
-        objects: List[Data] = []
+    def __parse_personalizations(self, personalization_events: List[Dict[str, Any]]) -> None:
+        if self.__personalizations is None:
+            self.__personalizations = {}
+        for personalization_event in reversed(personalization_events):
+            data = personalization_event.get("data")
+            if data is not None:
+                index = data.get("id")
+                variation_id = data.get("variationId")
+                if index is not None and variation_id is not None:
+                    if index not in self.__personalizations:
+                        self.__personalizations[index] = Personalization(index, variation_id)
+
+    def __single_data(self) -> Iterable[Data]:
         if self.__device:
-            objects.append(self.__device)
+            yield self.__device
         if self.__browser:
-            objects.append(self.__browser)
+            yield self.__browser
         if self.__operating_system:
-            objects.append(self.__operating_system)
+            yield self.__operating_system
         if self.__geolocation:
-            objects.append(self.__geolocation)
-        return objects
+            yield self.__geolocation
 
     @staticmethod
     def __parse_kcs_heat(kcs: Optional[Any]) -> Optional[KcsHeat]:

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.12.0}/kameleoon/network/network_manager_factory.py

@@ -15,6 +15,7 @@ class NetworkManagerFactory:
         call_timeout: float,
         net_provider: NetProvider,
         access_token_source_factory: AccessTokenSourceFactory,
+        network_domain: Optional[str],
     ) -> NetworkManager:
         """Creates and returns an instance of `NetworkManager` with the specified parameters."""
         raise NotImplementedError()

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.12.0}/kameleoon/network/network_manager_factory_impl.py

@@ -1,4 +1,5 @@
 """Network"""
+
 from typing import Optional
 from kameleoon.network.access_token_source_factory import AccessTokenSourceFactory
 from kameleoon.network.url_provider import UrlProvider
@@ -16,18 +17,20 @@ from kameleoon.network.services.data_service_impl import DataServiceImpl
 
 class NetworkManagerFactoryImpl(NetworkManagerFactory):
     """Network manager factory implementation"""
+
     # fmt is disabled due issue in pylint, disabling R0801 doesn’t work
     # fmt: off
     # pylint: disable=R0913
     def create(
         self,
         site_code: str,
-        environment: Optional[str], call_timeout: float,
+        environment: Optional[str], call_timeout: float,  # don`t change this line
         net_provider: NetProvider,
         access_token_source_factory: AccessTokenSourceFactory,
+        network_domain: Optional[str],
     ) -> NetworkManager:
         # fmt: on
-        url_provider = UrlProvider(site_code, UrlProvider.DEFAULT_DATA_API_DOMAIN)
+        url_provider = UrlProvider(site_code, network_domain)
         network_manager = NetworkManagerImpl(
             url_provider, environment, call_timeout, net_provider, access_token_source_factory,
         )

{kameleoon-client-python-3.10.0 → kameleoon-client-python-3.12.0}/kameleoon/network/query_builder.py

@@ -25,9 +25,11 @@ class QueryParams(str, Enum):
     KCS = "kcs"
     KEY = "key"
     MAX_NUMBER_PREVIOUS_VISITS = "maxNumberPreviousVisits"
+    METADATA = "metadata"
     NEGATIVE = "negative"
     NONCE = "nonce"
     OVERWRITE = "overwrite"
+    PERSONALIZATION = "personalization"
     REFERRERS_INDICES = "referrersIndices"
     REVENUE = "revenue"
     SDK_NAME = "sdkName"