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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.11.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.11.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.11.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.11.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.11.0 → kameleoon-client-python-3.12.0}/kameleoon/network/query_builder.py

@@ -29,6 +29,7 @@ class QueryParams(str, Enum):
     NEGATIVE = "negative"
     NONCE = "nonce"
     OVERWRITE = "overwrite"
+    PERSONALIZATION = "personalization"
     REFERRERS_INDICES = "referrersIndices"
     REVENUE = "revenue"
     SDK_NAME = "sdkName"

{kameleoon-client-python-3.11.0 → kameleoon-client-python-3.12.0}/kameleoon/network/url_provider.py

@@ -99,6 +99,7 @@ class UrlProvider:
             QueryParams.STATIC_DATA,
             data_filter.device or data_filter.browser or data_filter.operating_system,
         )
+        self.__add_flag_param_if_required(query_builder, QueryParams.PERSONALIZATION, data_filter.personalization)
         self.__add_flag_param_if_required(query_builder, QueryParams.CBS, data_filter.cbs)
         return self._DATA_API_URL_FORMAT.format(self._data_api_domain, self._VISITOR_DATA_PATH, str(query_builder))
 

{kameleoon-client-python-3.11.0 → kameleoon-client-python-3.12.0}/kameleoon/sdk_version.py

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

kameleoon-client-python-3.12.0/kameleoon/targeting/conditions/exclusive_experiment_condition.py

@@ -0,0 +1,55 @@
+"""Exclusive experiment condition"""
+
+from typing import Any, Union, Dict
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+from kameleoon.data.personalization import Personalization
+from kameleoon.data.manager.assigned_variation import AssignedVariation
+from kameleoon.targeting.conditions.targeting_condition import TargetingCondition
+
+
+class ExclusiveExperimentCondition(TargetingCondition):
+    """Exclusive experiment condition"""
+
+    # pylint: disable=R0903
+    class TargetingData:
+        """Represents targeting data for ExclusiveExperimentCondition"""
+
+        def __init__(
+            self,
+            current_experiment_id: int,
+            variations: Dict[int, AssignedVariation],
+            personalizations: Dict[int, Personalization],
+        ) -> None:
+            self.current_experiment_id = current_experiment_id
+            self.variations = variations
+            self.personalizations = personalizations
+
+    # pylint: disable=R0903
+    class CampaignType:
+        """Aggregates campaign types"""
+        EXPERIMENT = "EXPERIMENT"
+        PERSONALIZATION = "PERSONALIZATION"
+        ANY = "ANY"
+
+    def __init__(self, json_condition: Dict[str, Union[str, int, Any]]) -> None:
+        super().__init__(json_condition)
+        self.__campaign_type = json_condition.get("campaignType")
+
+    def check(self, data: TargetingData) -> bool:
+        if self.__campaign_type == self.CampaignType.EXPERIMENT:
+            return self.__check_experiment(data)
+        if self.__campaign_type == self.CampaignType.PERSONALIZATION:
+            return self.__check_personalization(data)
+        if self.__campaign_type == self.CampaignType.ANY:
+            return self.__check_personalization(data) and self.__check_experiment(data)
+        KameleoonLogger.error("Unexpected campaign type for %s condition: %s", self.type, self.__campaign_type)
+        return False
+
+    @staticmethod
+    def __check_experiment(data: TargetingData) -> bool:
+        size = len(data.variations)
+        return (size == 0) or ((size == 1) and data.variations.get(data.current_experiment_id) is not None)
+
+    @staticmethod
+    def __check_personalization(data: TargetingData) -> bool:
+        return len(data.personalizations) == 0

kameleoon-client-python-3.12.0/kameleoon/targeting/conditions/target_experiment_condition.py

@@ -0,0 +1,35 @@
+"""Target experiment condition"""
+
+from typing import cast, Any, Union, Dict
+from kameleoon.data.manager.assigned_variation import AssignedVariation
+from kameleoon.logging.kameleoon_logger import KameleoonLogger
+from kameleoon.targeting.conditions.constants import TargetingOperator
+from kameleoon.targeting.conditions.targeting_condition import TargetingCondition
+
+
+class TargetExperimentCondition(TargetingCondition):
+    """Target experiment condition"""
+
+    # pylint: disable=R0903
+    class TargetingData:
+        """Represents targeting data for TargetExperimentCondition"""
+
+        def __init__(self, variations: Dict[int, AssignedVariation]):
+            self.variations = variations
+
+    def __init__(self, json_condition: Dict[str, Union[str, int, Any]]):
+        super().__init__(json_condition)
+        self.__variation_id = json_condition.get("variationId", -1)
+        self.__experiment_id: int = cast(int, json_condition.get("experimentId", -1))
+        self.__variation_match_type = json_condition.get("variationMatchType")
+
+    def check(self, data: TargetingData) -> bool:
+        variation = data.variations.get(self.__experiment_id)
+        if self.__variation_match_type == TargetingOperator.ANY.value:
+            return variation is not None
+        if self.__variation_match_type == TargetingOperator.EXACT.value:
+            return (variation is not None) and (variation.variation_id == self.__variation_id)
+        KameleoonLogger.error(
+            "Unexpected variation match type for %s condition: %s", self.type, self.__variation_match_type
+        )
+        return False

kameleoon-client-python-3.12.0/kameleoon/targeting/conditions/target_personalization_condition.py

@@ -0,0 +1,23 @@
+"""Target personalization condition"""
+
+from typing import Any, Union, Dict
+from kameleoon.data.personalization import Personalization
+from kameleoon.targeting.conditions.targeting_condition import TargetingCondition
+
+
+class TargetPersonalizationCondition(TargetingCondition):
+    """Target personalization condition"""
+
+    # pylint: disable=R0903
+    class TargetingData:
+        """Represents targeting data for TargetPersonalizationCondition"""
+
+        def __init__(self, personalizations: Dict[int, Personalization]):
+            self.personalizations = personalizations
+
+    def __init__(self, json_condition: Dict[str, Union[int, Any]]):
+        super().__init__(json_condition)
+        self.__personalization_id = json_condition.get("personalizationId", -1)
+
+    def check(self, data: TargetingData) -> bool:
+        return data.personalizations.get(self.__personalization_id) is not None

{kameleoon-client-python-3.11.0 → kameleoon-client-python-3.12.0}/kameleoon/targeting/conditions/targeting_condition.py

@@ -14,7 +14,10 @@ class TargetingConditionType(Enum):
 
     CUSTOM_DATUM = "CUSTOM_DATUM"
     TARGET_FEATURE_FLAG = "TARGET_FEATURE_FLAG"
+    TARGET_EXPERIMENT = "TARGET_EXPERIMENT"
+    TARGET_PERSONALIZATION = "TARGET_PERSONALIZATION"
     EXCLUSIVE_FEATURE_FLAG = "EXCLUSIVE_FEATURE_FLAG"
+    EXCLUSIVE_EXPERIMENT = "EXCLUSIVE_EXPERIMENT"
     DEVICE_TYPE = "DEVICE_TYPE"
     VISITOR_CODE = "VISITOR_CODE"
     PAGE_URL = "PAGE_URL"

{kameleoon-client-python-3.11.0 → kameleoon-client-python-3.12.0}/kameleoon/targeting/targeting_manager.py

@@ -9,9 +9,12 @@ from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.managers.data.data_manager import DataManager
 from kameleoon.sdk_version import SdkVersion
 from kameleoon.targeting.conditions.exclusive_feature_flag_condition import ExclusiveFeatureFlagCondition
+from kameleoon.targeting.conditions.exclusive_experiment_condition import ExclusiveExperimentCondition
 from kameleoon.targeting.conditions.sdk_language_condition import SdkLanguageCondition
 from kameleoon.targeting.conditions.segment_condition import SegmentCondition
 from kameleoon.targeting.conditions.target_feature_flag_condition import TargetFeatureFlagCondition
+from kameleoon.targeting.conditions.target_experiment_condition import TargetExperimentCondition
+from kameleoon.targeting.conditions.target_personalization_condition import TargetPersonalizationCondition
 from kameleoon.targeting.conditions.targeting_condition import TargetingConditionType
 
 
@@ -72,10 +75,20 @@ class TargetingManager:
                 condition_data = ExclusiveFeatureFlagCondition.ExclusiveFeatureFlagInfo(
                     campaign_id, {} if visitor is None else visitor.variations
                 )
+            elif condition_type == TargetingConditionType.EXCLUSIVE_EXPERIMENT:
+                condition_data = ExclusiveExperimentCondition.TargetingData(
+                    campaign_id, visitor.variations if visitor else {}, visitor.personalizations if visitor else {}
+                )
             elif condition_type == TargetingConditionType.VISITOR_CODE:
                 condition_data = visitor_code
             elif condition_type == TargetingConditionType.SDK_LANGUAGE:
                 condition_data = SdkLanguageCondition.SdkInfo(SdkVersion.NAME, SdkVersion.VERSION)
+            elif condition_type == TargetingConditionType.TARGET_EXPERIMENT:
+                condition_data = TargetExperimentCondition.TargetingData(visitor.variations if visitor else {})
+            elif condition_type == TargetingConditionType.TARGET_PERSONALIZATION:
+                condition_data = TargetPersonalizationCondition.TargetingData(
+                    visitor.personalizations if visitor else {}
+                )
         KameleoonLogger.debug(
             "RETURN: TargetingManager.__get_condition_data(condition_type_literal: %s, visitor, visitor_code: %s,"
             " campaign_id: %s) -> (condition_data: %s)",

{kameleoon-client-python-3.11.0 → kameleoon-client-python-3.12.0}/kameleoon/targeting/tree_condition_factory.py

@@ -10,6 +10,7 @@ from kameleoon.targeting.conditions.unknown_condition import UnknownCondition
 from kameleoon.targeting.conditions.targeting_condition import TargetingCondition, TargetingConditionType
 from kameleoon.targeting.conditions.custom_datum import CustomDatum
 from kameleoon.targeting.conditions.exclusive_feature_flag_condition import ExclusiveFeatureFlagCondition
+from kameleoon.targeting.conditions.exclusive_experiment_condition import ExclusiveExperimentCondition
 from kameleoon.targeting.conditions.visitor_code_condition import VisitorCodeCondition
 from kameleoon.targeting.conditions.cookie_condition import CookieCondition
 from kameleoon.targeting.conditions.geolocation_condition import GeolocationCondition
@@ -17,6 +18,8 @@ from kameleoon.targeting.conditions.kcs_heat_range_condition import KcsHeatRange
 from kameleoon.targeting.conditions.operating_system_condition import OperatingSystemCondition
 from kameleoon.targeting.conditions.segment_condition import SegmentCondition
 from kameleoon.targeting.conditions.target_feature_flag_condition import TargetFeatureFlagCondition
+from kameleoon.targeting.conditions.target_experiment_condition import TargetExperimentCondition
+from kameleoon.targeting.conditions.target_personalization_condition import TargetPersonalizationCondition
 from kameleoon.targeting.conditions.page_view_number_condition import PageViewNumberCondition
 from kameleoon.targeting.conditions.previous_page_condition import PreviousPageCondition
 from kameleoon.targeting.conditions.visit_number_today_condition import VisitNumberTodayCondition
@@ -40,9 +43,18 @@ class TreeConditionFactory:
             if condition_type == TargetingConditionType.TARGET_FEATURE_FLAG:
                 return TargetFeatureFlagCondition(condition_json)
 
+            if condition_type == TargetingConditionType.TARGET_EXPERIMENT:
+                return TargetExperimentCondition(condition_json)
+
+            if condition_type == TargetingConditionType.TARGET_PERSONALIZATION:
+                return TargetPersonalizationCondition(condition_json)
+
             if condition_type == TargetingConditionType.EXCLUSIVE_FEATURE_FLAG:
                 return ExclusiveFeatureFlagCondition(condition_json)
 
+            if condition_type == TargetingConditionType.EXCLUSIVE_EXPERIMENT:
+                return ExclusiveExperimentCondition(condition_json)
+
             if condition_type == TargetingConditionType.DEVICE_TYPE:
                 return DeviceCondition(condition_json)
 

{kameleoon-client-python-3.11.0 → kameleoon-client-python-3.12.0}/kameleoon/types/remote_visitor_data_filter.py

@@ -20,6 +20,7 @@ class RemoteVisitorDataFilter:
         kcs=False,
         visitor_code=True,
         cbs=False,
+        personalization=False,
     ) -> None:
         self._previous_visit_amount = previous_visit_amount
         self._current_visit = current_visit
@@ -34,6 +35,7 @@ class RemoteVisitorDataFilter:
         self._kcs = kcs
         self._visitor_code = visitor_code
         self._cbs = cbs
+        self._personalization = personalization
 
     @property
     def previous_visit_amount(self) -> int:
@@ -100,6 +102,11 @@ class RemoteVisitorDataFilter:
         """True if CBS data will be retrieved"""
         return self._cbs
 
+    @property
+    def personalization(self) -> bool:
+        """True if personalization data will be retrieved"""
+        return self._personalization
+
     def __str__(self) -> str:
         return (
             f"RemoteVisitorDataFilter{{previous_visit_amount:{self._previous_visit_amount},"
@@ -107,5 +114,6 @@ class RemoteVisitorDataFilter:
             f"page_views:{self._page_views}, geolocation:{self._geolocation},"
             f"device:{self._device},browser:{self._browser},"
             f"operating_system:{self._operating_system},conversions:{self._conversions},"
-            f"experiments:{self._experiments},kcs:{self._kcs},visitor_code:{self._visitor_code}}},cbs:{self._cbs}"
+            f"experiments:{self._experiments},kcs:{self._kcs},visitor_code:{self._visitor_code}}},cbs:{self._cbs},"
+            f"personalization:{self._personalization}"
         )

{kameleoon-client-python-3.11.0 → kameleoon-client-python-3.12.0}/kameleoon_client_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kameleoon-client-python
-Version: 3.11.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.11.0 → kameleoon-client-python-3.12.0}/kameleoon_client_python.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ kameleoon/data/kcs_heat.py
 kameleoon/data/mapping_identifier.py
 kameleoon/data/operating_system.py
 kameleoon/data/page_view.py
+kameleoon/data/personalization.py
 kameleoon/data/unique_identifier.py
 kameleoon/data/user_agent.py
 kameleoon/data/visitor_visits.py
@@ -132,6 +133,7 @@ kameleoon/targeting/conditions/conversion_condition.py
 kameleoon/targeting/conditions/cookie_condition.py
 kameleoon/targeting/conditions/custom_datum.py
 kameleoon/targeting/conditions/device_condition.py
+kameleoon/targeting/conditions/exclusive_experiment_condition.py
 kameleoon/targeting/conditions/exclusive_feature_flag_condition.py
 kameleoon/targeting/conditions/geolocation_condition.py
 kameleoon/targeting/conditions/kcs_heat_range_condition.py
@@ -144,7 +146,9 @@ kameleoon/targeting/conditions/previous_page_condition.py
 kameleoon/targeting/conditions/sdk_language_condition.py
 kameleoon/targeting/conditions/segment_condition.py
 kameleoon/targeting/conditions/string_value_condition.py
+kameleoon/targeting/conditions/target_experiment_condition.py
 kameleoon/targeting/conditions/target_feature_flag_condition.py
+kameleoon/targeting/conditions/target_personalization_condition.py
 kameleoon/targeting/conditions/targeting_condition.py
 kameleoon/targeting/conditions/time_elapsed_since_visit_condition.py
 kameleoon/targeting/conditions/unknown_condition.py