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

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

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

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

@@ -18,6 +18,7 @@ class CustomDataInfo:
         self.__local_only = set()
         self.__visitor_scope = set()
         self.__custom_data_index_by_id = {}
+        self.__custom_data_index_by_name = {}
         if custom_data is not None:
             for data in custom_data:
                 index = data.get("index")
@@ -29,6 +30,8 @@ class CustomDataInfo:
                         self.__visitor_scope.add(index)
                     if (id_ := data.get("id")) is not None:
                         self.__custom_data_index_by_id[id_] = index
+                    if (name := data.get("name")) is not None:
+                        self.__custom_data_index_by_name[name] = index
                     if data.get("isMappingIdentifier"):
                         if bool(self.__mapping_identifier_index is not None):
                             KameleoonLogger.warning(
@@ -55,5 +58,9 @@ class CustomDataInfo:
         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"""
+        """Get corresponding custom data index by custom data id"""
         return self.__custom_data_index_by_id.get(custom_data_id)
+
+    def get_custom_data_index_by_name(self, custom_data_name: str) -> Optional[int]:
+        """Get corresponding custom data index by custom data name"""
+        return self.__custom_data_index_by_name.get(custom_data_name)

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

@@ -20,7 +20,7 @@ class DataFile:
     @staticmethod
     def default(environment: Optional[str]) -> "DataFile":
         """Creates new instance of `DataFile` initialized with default values"""
-        data_file = DataFile(environment, None, Settings(), {}, CustomDataInfo(None))
+        data_file = DataFile(environment, None, Settings(), {}, {}, CustomDataInfo(None))
         return data_file
 
     @staticmethod
@@ -33,13 +33,13 @@ class DataFile:
         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, last_modified, settings, feature_flags, custom_data_info, holdout)
+        data_file = DataFile(environment, last_modified, settings, segments, 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
+            (seg := Segment.from_json(jobj)).id_: seg
             for jobj in configuration.get("segments") or []
         }
 
@@ -58,18 +58,21 @@ class DataFile:
         environment: Optional[str],
         last_modified: Optional[str],
         settings: Settings,
+        segments: Dict[int, Segment],
         feature_flags: Dict[str, FeatureFlag],
         custom_data_info: CustomDataInfo,
         holdout: Optional[Experiment] = None,
     ) -> None:
         KameleoonLogger.debug(
-            "CALL: DataFile(environment: %s, last_modified: %s, settings: %s, feature_flags: %s,"
+            "CALL: DataFile(environment: %s, last_modified: %s, settings: %s, segments, feature_flags,"
             " custom_data_info: %s, holdout: %s)",
-            environment, last_modified, settings, feature_flags, custom_data_info, holdout
+            environment, last_modified, settings, custom_data_info, holdout
         )
         self.__environment = environment  # pylint: disable=W0238
         self.__last_modified = last_modified
         self.__settings = settings
+        self.__segments = segments
+        self.__audience_tracking_segments = [seg for seg in segments.values() if seg.audience_tracking]
         self.__feature_flags: Dict[str, FeatureFlag] = feature_flags
         self.__me_groups = self.__make_me_groups(feature_flags.values())
         self.__has_any_targeted_delivery_rule = any(
@@ -79,7 +82,6 @@ class DataFile:
             for rule in ff.rules
         )
         self.__variation_by_id: Dict[int, VariationByExposition] = {}
-        self.__rule_by_segment_id: Dict[int, Rule] = {}
         self.__rule_info_by_exp_id: Dict[int, DataFile.RuleInfo] = {}
         self.__feature_flag_by_id: Dict[int, FeatureFlag] = {}
         self.__experiment_ids_with_js_css_variable: Set[int] = set()
@@ -87,9 +89,9 @@ class DataFile:
         self.__custom_data_info = custom_data_info
         self.__holdout = holdout
         KameleoonLogger.debug(
-            "RETURN: DataFile(environment: %s, last_modified: %s, settings: %s, feature_flags: %s,"
+            "RETURN: DataFile(environment: %s, last_modified: %s, settings: %s, segments, feature_flags,"
             " custom_data_info: %s, holdout: %s)",
-            environment, last_modified, settings, feature_flags, custom_data_info, holdout
+            environment, last_modified, settings, custom_data_info, holdout
         )
 
     @property
@@ -102,6 +104,16 @@ class DataFile:
         """Returns settings"""
         return self.__settings
 
+    @property
+    def segments(self) -> Dict[int, Segment]:
+        """Returns segments"""
+        return self.__segments
+
+    @property
+    def audience_tracking_segments(self) -> List[Segment]:
+        """Returns audience tracking segments"""
+        return self.__audience_tracking_segments
+
     @property
     def feature_flags(self) -> Dict[str, FeatureFlag]:
         """Returns dictionary of all feature flags stored by feature keys"""
@@ -117,11 +129,6 @@ class DataFile:
         """Returns dictionary of all feature flags stored by id"""
         return self.__feature_flag_by_id
 
-    @property
-    def rule_by_segment_id(self) -> Dict[int, Rule]:
-        """Returns dictionary of all rule stored by segment id"""
-        return self.__rule_by_segment_id
-
     @property
     def rule_info_by_exp_id(self) -> Dict[int, "DataFile.RuleInfo"]:
         """Returns dictionary of all rule related info stored by experiment id"""
@@ -169,7 +176,6 @@ class DataFile:
             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
                     self.__rule_info_by_exp_id[rule.experiment.id_] = DataFile.RuleInfo(feature_flag, rule)
                     if has_feature_flag_variable_js_css:
                         self.__experiment_ids_with_js_css_variable.add(rule.experiment.id_)

kameleoon-client-python-3.16.0/kameleoon/data/custom_data.py

@@ -0,0 +1,90 @@
+"""Custom data"""
+
+import json
+from typing import Optional, Tuple, Union
+from kameleoon.data.data import Data, DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
+from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
+
+
+class CustomData(Data, DuplicationUnsafeSendableBase):
+    """Custom data"""
+
+    EVENT_TYPE = "customData"
+
+    def __init__(self, index_or_name: Union[int, str], *args: str, overwrite=True) -> None:
+        """
+        :param index_or_name: Index or Name of the custom data. This field is mandatory.
+        :type index_or_name: Union[int, str]
+        :param args: Values of the custom data to be stored. This field is mandatory.
+        :type args: *str
+        :param overwrite: Flag to explicitly control how the values are stored and how they appear in reports.
+        This field is optional, `True` by default.
+        :type overwrite: bool
+        """
+        # pylint: disable=invalid-name,redefined-builtin
+        super().__init__()
+        # pylint: disable=W0511
+        if isinstance(index_or_name, int):
+            self.__index = index_or_name
+            self._name = None
+        else:
+            self.__index = -1
+            self._name = index_or_name
+        self.__values = args
+        self.__overwrite = overwrite
+
+    def _named_to_indexed(self, index: int) -> "CustomData":
+        """Makes an indexed Custom Data instance based on the current instance"""
+        custom_data = CustomData(index, *self.__values, overwrite=self.__overwrite)
+        custom_data._name = self._name
+        return custom_data
+
+    @property
+    def id(self) -> int:  # pylint: disable=C0103
+        """
+        Deprecated. Please use `index` instead.
+
+        Returns index
+        """
+        return self.__index
+
+    @property
+    def index(self) -> int:
+        """Returns index"""
+        return self.__index
+
+    @property
+    def name(self) -> Optional[str]:
+        """Returns name"""
+        return self._name
+
+    @property
+    def values(self) -> Tuple[str, ...]:
+        """Returns values"""
+        return self.__values
+
+    @property
+    def overwrite(self) -> bool:
+        """Returns overwrite"""
+        return self.__overwrite
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.CUSTOM_DATA
+
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        str_values = json.dumps({v: 1 for v in self.__values}, separators=(",", ":"))
+        query_builder.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE, False),
+            QueryParam(QueryParams.INDEX, str(self.id), False),
+            QueryParam(QueryParams.VALUES_COUNT_MAP, str_values),
+            QueryParam(QueryParams.OVERWRITE, "true" if self.__overwrite else "false", False),
+        )
+
+    def __str__(self):
+        return (
+            "CustomData{"
+            f"index:{self.__index},name:'{self._name}',values:{self.__values},overwrite:{self.__overwrite}"
+            "}"
+        )

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/data/data.py

@@ -24,6 +24,7 @@ class DataType(IntEnum):
     FORCED_FEATURE_VARIATION = 15
     CBS = 16
     PERSONALIZATION = 17
+    TARGETED_SEGMENT = 18
 
 
 class BaseData:

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/data/manager/assigned_variation.py

@@ -62,7 +62,7 @@ class AssignedVariation(BaseData, DuplicationUnsafeSendableBase):
         """Checks if the assigned variation is valid based on the respool time."""
         return (respool_time is None) or (self.assignment_time >= respool_time)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return (
             f"AssignedVariation{{experiment_id:{self.__experiment_id},"
             f"variation_id:{self.__variation_id},"

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

@@ -18,6 +18,7 @@ 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.targeted_segment import TargetedSegment
 from kameleoon.data.unique_identifier import UniqueIdentifier
 from kameleoon.data.user_agent import UserAgent
 from kameleoon.data.manager.assigned_variation import AssignedVariation
@@ -142,6 +143,13 @@ class Visitor:  # pylint: disable=R0904
         KameleoonLogger.debug('CALL/RETURN: Visitor.personalizations -> (personalizations: %s)', personalizations)
         return personalizations
 
+    @property
+    def targeted_segments(self) -> Dict[int, TargetedSegment]:
+        """Returns the personalizations associated with this Visitor."""
+        targeted_segments = EMPTY_DICT if self._data.targeted_segments is None else self._data.targeted_segments.copy()
+        KameleoonLogger.debug('CALL/RETURN: Visitor.targeted_segments -> (targeted_segments: %s)', targeted_segments)
+        return targeted_segments
+
     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.
@@ -219,6 +227,8 @@ class Visitor:  # pylint: disable=R0904
         KameleoonLogger.debug('CALL: Visitor.add_data(args: %s, overwrite: %s)', args, overwrite)
         with self._data.lock:
             for data in args:
+                if data is None:
+                    continue
                 data_type = type(data)
                 data_adder = self.DATA_ADDERS.get(data_type)
                 if data_adder:
@@ -283,6 +293,7 @@ class Visitor:  # pylint: disable=R0904
             self.conversions: Optional[List[Conversion]] = None
             self.variations: Optional[Dict[int, AssignedVariation]] = None
             self.personalizations: Optional[Dict[int, Personalization]] = None
+            self.targeted_segments: Optional[Dict[int, TargetedSegment]] = None
             self.forced_variations: Optional[Dict[int, ForcedExperimentVariation]] = None
             self.simulated_variations: Optional[Dict[str, ForcedFeatureVariation]] = None
             self.kcs_heat: Optional[KcsHeat] = None
@@ -309,6 +320,8 @@ class Visitor:  # pylint: disable=R0904
                 yield from (visit.page_view for visit in list(self.page_view_visits.values()))
             if self.variations is not None:
                 yield from list(self.variations.values())
+            if self.targeted_segments is not None:
+                yield from list(self.targeted_segments.values())
             if self.conversions is not None:
                 yield from list(self.conversions)
 
@@ -331,6 +344,8 @@ class Visitor:  # pylint: disable=R0904
                 count += len(self.page_view_visits)
             if self.variations is not None:
                 count += len(self.variations)
+            if self.targeted_segments is not None:
+                count += len(self.targeted_segments)
             if self.conversions is not None:
                 count += len(self.conversions)
             return count
@@ -374,6 +389,12 @@ class Visitor:  # pylint: disable=R0904
         if context.overwrite or personalization.id not in self._data.personalizations:
             self._data.personalizations[personalization.id] = personalization
 
+    def _add_targeted_segment(self, context: DataAddingContext) -> None:
+        targeted_segment = cast(TargetedSegment, context.data)
+        if self._data.targeted_segments is None:
+            self._data.targeted_segments = {}
+        self._data.targeted_segments[targeted_segment.id] = targeted_segment
+
     def _add_forced_feature_variation(self, context: DataAddingContext) -> None:
         ffv = cast(ForcedFeatureVariation, context.data)
         if self._data.simulated_variations is None:
@@ -405,8 +426,8 @@ class Visitor:  # pylint: disable=R0904
         custom_data = cast(CustomData, context.data)
         if self._data.custom_data_dict is None:
             self._data.custom_data_dict = {}
-        if context.overwrite or custom_data.id not in self._data.custom_data_dict:
-            self._data.custom_data_dict[custom_data.id] = custom_data
+        if context.overwrite or custom_data.index not in self._data.custom_data_dict:
+            self._data.custom_data_dict[custom_data.index] = custom_data
 
     def _add_page_view(self, context: DataAddingContext) -> None:
         page_view = cast(PageView, context.data)
@@ -471,6 +492,7 @@ class Visitor:  # pylint: disable=R0904
         VisitorVisits: _set_visitor_visits,
         AssignedVariation: _add_variation,
         Personalization: _add_personalization,
+        TargetedSegment: _add_targeted_segment,
         ForcedFeatureVariation: _add_forced_feature_variation,
         ForcedExperimentVariation: _add_forced_experiment_variation,
         UniqueIdentifier: _set_is_unique_identifier,

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/data/manager/visitor_manager.py

@@ -87,15 +87,20 @@ class VisitorManager:
 
     def __process_custom_data(
         self, visitor_code: str, visitor: Visitor, custom_data_info: CustomDataInfo, custom_data: CustomData
-    ) -> CustomData:
+    ) -> Optional[CustomData]:
         """Processes custom data, potentially modifying or mapping it based on certain conditions."""
+        if custom_data.name is not None:
+            cd_index = custom_data_info.get_custom_data_index_by_name(custom_data.name)
+            if cd_index is None:
+                return None
+            custom_data = custom_data._named_to_indexed(cd_index)
         # We shouldn't send custom data with local only type
-        if custom_data_info.is_local_only(custom_data.id):
+        if custom_data_info.is_local_only(custom_data.index):
             custom_data.mark_as_sent()
         # If mappingIdentifier is passed, we should link anonymous visitor with real unique userId.
         # After authorization, customer must be able to continue work with userId, but hash for variation
         # should be calculated based on anonymous visitor code, that's why set MappingIdentifier to visitor.
-        if custom_data_info.is_mapping_identifier(custom_data.id) and custom_data.values and custom_data.values[0]:
+        if custom_data_info.is_mapping_identifier(custom_data.index) and custom_data.values and custom_data.values[0]:
             visitor.mapping_identifier = visitor_code
             user_id = custom_data.values[0]
             if visitor_code != user_id:

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/data/mapping_identifier.py

@@ -6,7 +6,8 @@ from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParam
 class MappingIdentifier(CustomData):
     """Mapping identifier"""
     def __init__(self, custom_data: CustomData) -> None:
-        super().__init__(custom_data.id, *custom_data.values)
+        super().__init__(custom_data.index, *custom_data.values, overwrite=custom_data.overwrite)
+        self._name = custom_data.name
 
     @property
     def unsent(self) -> bool:

kameleoon-client-python-3.16.0/kameleoon/data/targeted_segment.py

@@ -0,0 +1,34 @@
+"""Targeted Segment"""
+from kameleoon.data.data import BaseData, DataType
+from kameleoon.network.sendable import DuplicationUnsafeSendableBase
+from kameleoon.network.query_builder import QueryBuilder, QueryParam, QueryParams
+
+
+class TargetedSegment(BaseData, DuplicationUnsafeSendableBase):
+    """Targeted Segment"""
+    EVENT_TYPE = "targetingSegment"
+
+    def __init__(self, id_: int) -> None:
+        super().__init__()
+        self.__id = id_
+
+    @property
+    def id(self) -> int:  # pylint: disable=C0103
+        """Returns the segment ID."""
+        return self.__id
+
+    @property
+    def data_type(self) -> DataType:
+        """Returns the data type for the targeted segment."""
+        return DataType.TARGETED_SEGMENT
+
+    def _add_query_params(self, query_builder: QueryBuilder) -> None:
+        # fmt: off
+        query_builder.extend(
+            QueryParam(QueryParams.EVENT_TYPE, self.EVENT_TYPE),
+            QueryParam(QueryParams.SEGMENT_ID, str(self.__id)),
+        )
+        # fmt: on
+
+    def __str__(self) -> str:
+        return f"TargetedSegment{{id:{self.__id}}}"

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

@@ -17,6 +17,7 @@ from kameleoon.data.manager.assigned_variation import AssignedVariation
 from kameleoon.data.manager.forced_experiment_variation import ForcedExperimentVariation
 from kameleoon.data.manager.visitor import Visitor
 from kameleoon.data.manager.visitor_manager import VisitorManager
+from kameleoon.data.targeted_segment import TargetedSegment
 
 from kameleoon.exceptions import (
     FeatureVariationNotFound,
@@ -1380,7 +1381,7 @@ class KameleoonClient:
             campaign_id,
             rule,
         )
-        targeting = self._targeting_manager.check_targeting(visitor_code, campaign_id, rule)
+        targeting = self._targeting_manager.check_targeting(visitor_code, campaign_id, rule.targeting_segment)
         KameleoonLogger.debug(
             "RETURN: KameleoonClient.__check_targeting(visitor_code: %s, campaign_id: %s, rule: %s) -> "
             "(targeting: %s)",
@@ -1782,3 +1783,25 @@ class KameleoonClient:
             variation_key,
             force_targeting,
         )
+
+    def evaluate_audiences(self, visitor_code: str) -> None:
+        """
+        Evaluates the visitor against all available Audiences Explorer segments and tracks those that match.
+        A detailed analysis of segment performance can then be performed directly in Audiences Explorer.
+
+        :param visitor_code: The unique visitor code identifying the visitor.
+        :type visitor_code: str
+
+        :raises VisitorCodeInvalid: The provided **visitor code** is invalid.
+        """
+        KameleoonLogger.info("CALL: KameleoonClient.evaluate_audiences(visitor_code: %s)", visitor_code)
+        validate_visitor_code(visitor_code)
+        segments = [
+            TargetedSegment(seg.id_)
+            for seg in self._data_manager.data_file.audience_tracking_segments
+            if self._targeting_manager.check_targeting(visitor_code, None, seg)
+        ]
+        if segments:
+            self._visitor_manager.add_data(visitor_code, *segments)
+        self._tracking_manager.add_visitor_code(visitor_code)
+        KameleoonLogger.info("RETURN: KameleoonClient.evaluate_audiences(visitor_code: %s)", visitor_code)

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/managers/remote_data/remote_visitor_data.py

@@ -103,7 +103,7 @@ class RemoteVisitorData:
         """Marks data as sent based on the provided `custom_data_info`."""
         if self.__custom_data_dict:
             for data in self.__custom_data_dict.values():
-                if custom_data_info is None or not custom_data_info.is_visitor_scope(data.id):
+                if custom_data_info is None or not custom_data_info.is_visitor_scope(data.index):
                     data.mark_as_sent()
         if self.__experiments:
             for experiment in self.__experiments.values():

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/middleware.py

@@ -32,7 +32,6 @@ class KameleoonWSGIMiddleware:
                 environ["HTTP_COOKIE"] = f"{VISITOR_CODE_COOKIE}={visitor_code}"
 
         def _custom_start_response(status, headers, exc_info=None):
-            # pylint: disable=W0212
             self._client._cookie_manager.update(visitor_code, self._client._is_consent_given(visitor_code), cookies)
             headers.append(("Set-Cookie", cookies.output(header="")))
             return start_response(status, headers, exc_info)

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/network/query_builder.py

@@ -48,6 +48,7 @@ class QueryParams(str, Enum):
     REVENUE = "revenue"
     SDK_NAME = "sdkName"
     SDK_VERSION = "sdkVersion"
+    SEGMENT_ID = "id"
     SITE_CODE = "siteCode"
     STATIC_DATA = "staticData"
     TIME_SINCE_PREVIOUS_VISIT = "timeSincePreviousVisit"

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/sdk_version.py

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

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/targeting/conditions/exclusive_experiment_condition.py

@@ -35,7 +35,9 @@ class ExclusiveExperimentCondition(TargetingCondition):
         super().__init__(json_condition)
         self.__campaign_type = json_condition.get("campaignType")
 
-    def check(self, data: TargetingData) -> bool:
+    def check(self, data: Any) -> bool:
+        if not isinstance(data, self.TargetingData):
+            return False
         if self.__campaign_type == self.CampaignType.EXPERIMENT:
             return self.__check_experiment(data)
         if self.__campaign_type == self.CampaignType.PERSONALIZATION:

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/targeting/conditions/segment_condition.py

@@ -42,5 +42,5 @@ class SegmentCondition(TargetingCondition):
         return isinstance(data, SegmentCondition.SegmentInfo) and self.__check(data)
 
     def __check(self, segment_info: SegmentInfo) -> bool:
-        rule = segment_info.data_file().rule_by_segment_id.get(self.__segment_id)
-        return rule is not None and rule.targeting_segment.check_tree(segment_info.condition_data())
+        segment = segment_info.data_file().segments.get(self.__segment_id)
+        return segment is not None and segment.check_tree(segment_info.condition_data())

kameleoon-client-python-3.16.0/kameleoon/targeting/models.py

@@ -0,0 +1,28 @@
+"""Targeting Segment"""
+
+from typing import Any, Dict, Optional
+from kameleoon.targeting.tree_builder import create_tree, Tree
+
+
+class Segment:
+    """Segment with targeting data"""
+
+    def __init__(self, id_: int, tree: Optional[Tree], audience_tracking: bool) -> None:
+        self.id_ = id_
+        self.tree = tree
+        self.audience_tracking = audience_tracking
+
+    @staticmethod
+    def from_json(obj: Dict[str, Any]) -> "Segment":
+        """Creates a Segment instance from JSON object"""
+        id_ = obj.get("id", -1)
+        tree = create_tree(obj.get("conditionsData"))
+        audience_tracking = obj.get("audienceTracking", False)
+        return Segment(id_, tree, audience_tracking)
+
+    def check_tree(self, get_targeting_data) -> Optional[bool]:
+        """Checks the targeting throught targeting tree"""
+        return self.tree.check(get_targeting_data) if self.tree else True
+
+    def __str__(self) -> str:
+        return f"Segment{{id:{self.id_},audience_tracking:{self.audience_tracking}}}"

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon/targeting/targeting_manager.py

@@ -1,7 +1,6 @@
 """Targeting Segment"""
 
 from typing import Optional
-from kameleoon.configuration.rule import Rule
 from kameleoon.data.manager.visitor import Visitor
 from kameleoon.data.manager.visitor_manager import VisitorManager
 from kameleoon.helpers.functions import enum_from_literal
@@ -16,6 +15,7 @@ from kameleoon.targeting.conditions.target_experiment_condition import TargetExp
 from kameleoon.targeting.conditions.target_personalization_condition import TargetPersonalizationCondition
 from kameleoon.targeting.conditions.targeting_condition import TargetingConditionType
 from kameleoon.targeting.conditions.visit_number_today_condition import VisitNumberTodayCondition
+from kameleoon.targeting.models import Segment
 
 
 class TargetingManager:
@@ -26,22 +26,23 @@ class TargetingManager:
         self.__visitor_manager = visitor_manager
 
     # pylint: disable=W0238
-    def check_targeting(self, visitor_code: str, campaign_id: int, rule: Rule):
+    def check_targeting(self, visitor_code: str, campaign_id: Optional[int], segment: Optional[Segment]):
         """Check if visitor is targeted for rule"""
         KameleoonLogger.debug(
-            "CALL: TargetingManager.check_targeting(visitor_code: %s, campaign_id: %s, rule: %s)",
-            visitor_code, campaign_id, rule
+            "CALL: TargetingManager.check_targeting(visitor_code: %s, campaign_id: %s, segment: %s)",
+            visitor_code, campaign_id, segment
         )
-        segment = rule.targeting_segment
         if segment is None:
             targeting: Optional[bool] = True
         else:
             visitor = self.__visitor_manager.get_visitor(visitor_code)
-            targeting = segment.check_tree(lambda type: self.__get_condition_data(type, visitor, visitor_code,
-                                                                                  campaign_id))
-        KameleoonLogger.debug("RETURN: TargetingManager.check_targeting(visitor_code: %s, campaign_id: %s, "
-                              "rule: %s) -> (targeting: %s)",
-                              visitor_code, campaign_id, rule, targeting)
+            targeting = segment.check_tree(
+                lambda type: self.__get_condition_data(type, visitor, visitor_code, campaign_id)
+            )
+        KameleoonLogger.debug(
+            "RETURN: TargetingManager.check_targeting(visitor_code: %s, campaign_id: %s, "
+            "segment: %s) -> (targeting: %s)", visitor_code, campaign_id, segment, targeting
+        )
         return targeting
 
     # pylint: disable=R0911
@@ -50,9 +51,9 @@ class TargetingManager:
         condition_type_literal: str,
         visitor: Optional[Visitor],
         visitor_code: str,
-        campaign_id: int,
+        campaign_id: Optional[int],
     ):
-        # pylint: disable=E1101,W0212
+        # pylint: disable=E1101
         KameleoonLogger.debug(
             "CALL: TargetingManager.__get_condition_data(condition_type_literal: %s, visitor, visitor_code: %s, "
             "campaign_id: %s)", condition_type_literal, visitor_code, campaign_id
@@ -72,9 +73,10 @@ class TargetingManager:
                     lambda type: self.__get_condition_data(type, visitor, visitor_code, campaign_id),
                 )
             elif condition_type == TargetingConditionType.EXCLUSIVE_EXPERIMENT:
-                condition_data = ExclusiveExperimentCondition.TargetingData(
-                    campaign_id, visitor.variations if visitor else {}, visitor.personalizations if visitor else {}
-                )
+                if campaign_id is not None:
+                    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:

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

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

{kameleoon-client-python-3.14.0 → kameleoon-client-python-3.16.0}/kameleoon_client_python.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ kameleoon/data/mapping_identifier.py
 kameleoon/data/operating_system.py
 kameleoon/data/page_view.py
 kameleoon/data/personalization.py
+kameleoon/data/targeted_segment.py
 kameleoon/data/unique_identifier.py
 kameleoon/data/user_agent.py
 kameleoon/data/visitor_visits.py