kameleoon-client-python 3.16.2__tar.gz → 3.17.0__tar.gz

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kameleoon-client-python
-Version: 3.16.2
+Version: 3.17.0
 Summary: Kameleoon Client Python Software Development Kit.
 Home-page: https://developers.kameleoon.com/python-sdk.html
 Author: Kameleoon
@@ -20,27 +20,27 @@ Requires-Dist: requests<3.0.0,>=2.25
 Requires-Dist: sseclient-py<1.9.0,>=1.7.0
 Requires-Dist: aiohttp<4.0.0,>=3.8.0
 Provides-Extra: test
-Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
-Requires-Dist: Django==3.2.4; extra == "test"
-Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
-Requires-Dist: aioresponses==0.7.*; extra == "test"
-Requires-Dist: pylint==2.12.*; extra == "test"
-Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
+Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
+Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
 Requires-Dist: freezegun==1.1.0; extra == "test"
-Requires-Dist: wheel==0.36.2; extra == "test"
-Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
-Requires-Dist: flake8==4.0.1; extra == "test"
-Requires-Dist: pytest-cov==2.12.1; extra == "test"
-Requires-Dist: types-requests==2.25.0; extra == "test"
-Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
-Requires-Dist: mypy==0.991; extra == "test"
 Requires-Dist: twine==3.4.1; extra == "test"
-Requires-Dist: types-PyYAML==5.4.3; extra == "test"
+Requires-Dist: wheel==0.36.2; extra == "test"
 Requires-Dist: Werkzeug==2.0.1; extra == "test"
+Requires-Dist: mypy==0.991; extra == "test"
 Requires-Dist: pytest-ordering==0.6; extra == "test"
-Requires-Dist: pytest-asyncio==0.21.*; extra == "test"
+Requires-Dist: pytest-cov==2.12.1; extra == "test"
+Requires-Dist: sseclient-py<1.9.0,>=1.7.0; extra == "test"
+Requires-Dist: aioresponses==0.7.*; extra == "test"
 Requires-Dist: pytest-django==4.4.0; extra == "test"
-Requires-Dist: aiohttp<4.0.0,>=3.8.0; extra == "test"
+Requires-Dist: Django==3.2.4; extra == "test"
+Requires-Dist: requests<3.0.0,>=2.25; extra == "test"
+Requires-Dist: flake8==4.0.1; extra == "test"
+Requires-Dist: pyyaml<6.1.0,>=5.4.0; extra == "test"
+Requires-Dist: pylint==2.12.*; extra == "test"
+Requires-Dist: types-PyYAML==5.4.3; extra == "test"
+Requires-Dist: pytest-pythonpath==0.7.3; extra == "test"
+Requires-Dist: types-requests==2.25.0; extra == "test"
+Requires-Dist: types-python-dateutil==2.8.2; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

kameleoon_client_python-3.17.0/kameleoon/configuration/consent_blocking_behaviour.py

@@ -0,0 +1,16 @@
+"""Kameleoon Configuration"""
+
+from enum import Enum
+from kameleoon.helpers.functions import enum_from_literal
+
+
+class ConsentBlockingBehaviour(Enum):
+    """Possible Consent Blocking Behaviour types"""
+
+    PARTIALLY_BLOCKED = "PARTIALLY_BLOCK"
+    COMPLETELY_BLOCKED = "FULLY_BLOCK"
+
+    @staticmethod
+    def from_str(s: str) -> "ConsentBlockingBehaviour":
+        """Makes ConsentBlockingBehaviour from string"""
+        return enum_from_literal(s, ConsentBlockingBehaviour, ConsentBlockingBehaviour.PARTIALLY_BLOCKED)

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/configuration/data_file.py

@@ -48,7 +48,7 @@ class DataFile:
         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
+            (ff := FeatureFlag(jobj, segments, cdi)).feature_key: ff
             for jobj in configuration.get("featureFlags") or []
         }
 
@@ -153,7 +153,8 @@ class DataFile:
         if feature_flag is None:
             raise FeatureNotFound(feature_key)
         if not feature_flag.environment_enabled:
-            raise FeatureEnvironmentDisabled(feature_key, self.__environment)
+            env = "default" if self.__environment is None else f"'{self.__environment}'"
+            raise FeatureEnvironmentDisabled(f"Feature '{feature_key}' is disabled for {env} environment")
         return feature_flag
 
     @property

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/configuration/settings.py

@@ -1,6 +1,7 @@
 """Kameleoon Configuration"""
 
 from typing import Any, Dict, Optional
+from kameleoon.configuration.consent_blocking_behaviour import ConsentBlockingBehaviour
 
 
 class Settings:
@@ -17,6 +18,8 @@ class Settings:
             configuration = {}
         self.__real_time_update: bool = bool(configuration.get("realTimeUpdate"))
         self.__is_consent_required = configuration.get("consentType") == self._CONSENT_TYPE_REQUIRED
+        self.__blocking_behaviour_if_consent_not_given = \
+            ConsentBlockingBehaviour.from_str(configuration.get("consentOptOutBehavior", ""))
         self.__data_api_domain = configuration.get("dataApiDomain")
 
     @property
@@ -29,6 +32,11 @@ class Settings:
         """Returns consent required flag state"""
         return self.__is_consent_required
 
+    @property
+    def blocking_behaviour_if_consent_not_given(self) -> ConsentBlockingBehaviour:
+        """Returns blocking behaviour if consent not given"""
+        return self.__blocking_behaviour_if_consent_not_given
+
     @property
     def data_api_domain(self) -> Any:
         """Returns Data API domain to be switched to"""
@@ -38,5 +46,6 @@ class Settings:
         return (
             f"Settings{{real_time_update:{self.__real_time_update},"
             f"is_consent_required:{self.__is_consent_required},"
+            f"blocking_behaviour_if_consent_not_given:{self.__blocking_behaviour_if_consent_not_given},"
             f"data_api_domain:'{self.__data_api_domain}'}}"
         )

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/data/conversion.py

@@ -44,7 +44,7 @@ class Conversion(Data, DuplicationSafeSendableBase):
         self.__goal_id = goal_id
         self.__revenue = revenue
         self.__negative = negative
-        self.__metadata = metadata
+        self._metadata = metadata
 
     @property
     def goal_id(self) -> int:
@@ -64,7 +64,7 @@ class Conversion(Data, DuplicationSafeSendableBase):
     @property
     def metadata(self) -> Optional[Iterable[CustomData]]:
         """Returns metadata"""
-        return self.__metadata
+        return self._metadata
 
     @property
     def data_type(self) -> DataType:
@@ -97,5 +97,5 @@ class Conversion(Data, DuplicationSafeSendableBase):
             f"Conversion{{goal_id:{self.__goal_id},"
             f"revenue:{self.__revenue},"
             f"negative:{self.__negative},"
-            f"metadata:{StringUtils.object_to_string(self.__metadata)}}}"
+            f"metadata:{StringUtils.object_to_string(self._metadata)}}}"
         )

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/data/custom_data.py

@@ -11,6 +11,7 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
     """Custom data"""
 
     EVENT_TYPE = "customData"
+    UNDEFINED_INDEX = -1
 
     def __init__(self, index_or_name: Union[int, str], *args: str, overwrite=True) -> None:
         """
@@ -29,7 +30,7 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
             self.__index = index_or_name
             self._name = None
         else:
-            self.__index = -1
+            self.__index = self.UNDEFINED_INDEX
             self._name = index_or_name
         self.__values = args
         self.__overwrite = overwrite
@@ -41,7 +42,7 @@ class CustomData(Data, DuplicationUnsafeSendableBase):
         return custom_data
 
     @property
-    def id(self) -> int:  # pylint: disable=C0103
+    def id(self) -> int:
         """
         Deprecated. Please use `index` instead.
 

kameleoon_client_python-3.17.0/kameleoon/data/manager/legal_consent.py

@@ -0,0 +1,11 @@
+"""Legal Consent"""
+
+from enum import Enum
+
+
+class LegalConsent(Enum):
+    """Possible Legal Consent states"""
+
+    UNKNOWN = 0
+    GIVEN = 1
+    NOT_GIVEN = 2

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/data/manager/visitor.py

@@ -24,6 +24,7 @@ from kameleoon.data.user_agent import UserAgent
 from kameleoon.data.manager.assigned_variation import AssignedVariation
 from kameleoon.data.manager.forced_experiment_variation import ForcedExperimentVariation
 from kameleoon.data.manager.forced_feature_variation import ForcedFeatureVariation
+from kameleoon.data.manager.legal_consent import LegalConsent
 from kameleoon.data.manager.page_view_visit import PageViewVisit
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.network.sendable import Sendable
@@ -246,7 +247,7 @@ class Visitor:  # pylint: disable=R0904
         return mapping_identifier
 
     @mapping_identifier.setter
-    def mapping_identifier(self, value: str):
+    def mapping_identifier(self, value: str) -> None:
         """Sets the mapping identifier for this Visitor."""
         if self._data.mapping_identifier:
             return
@@ -257,14 +258,14 @@ class Visitor:  # pylint: disable=R0904
         KameleoonLogger.debug("CALL/RETURN: Visitor.mapping_identifier <- (mapping_identifier: %s)", value)
 
     @property
-    def legal_consent(self) -> bool:
+    def legal_consent(self) -> LegalConsent:
         """Returns the legal consent status for this Visitor."""
         legal_consent = self._data.legal_consent
         KameleoonLogger.debug('CALL/RETURN: Visitor.legal_consent -> (legal_consent: %s)', legal_consent)
         return legal_consent
 
     @legal_consent.setter
-    def legal_consent(self, value: bool):
+    def legal_consent(self, value: LegalConsent) -> None:
         """Sets the legal consent status for this Visitor."""
         self._data.legal_consent = value
         KameleoonLogger.debug("CALL/RETURN: Visitor.legal_consent <- (legal_consent: %s)", value)
@@ -300,7 +301,7 @@ class Visitor:  # pylint: disable=R0904
             self.cbscores: Optional[CBScores] = None
             self.visitor_visits: Optional[VisitorVisits] = None
             self.mapping_identifier: Optional[str] = None
-            self.legal_consent = False
+            self.legal_consent = LegalConsent.UNKNOWN
 
         def enumerate_sendable_data(self) -> Iterator[Sendable]:
             """Iterates over all sendable data associated with the visitor."""

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/data/manager/visitor_manager.py

@@ -3,7 +3,7 @@ import collections
 import time
 from typing import Any, Dict, Iterator, List, Optional
 from kameleoon.configuration.custom_data_info import CustomDataInfo
-from kameleoon.data import CustomData
+from kameleoon.data import Conversion, CustomData
 from kameleoon.data.mapping_identifier import MappingIdentifier
 from kameleoon.data.manager.visitor import Visitor
 from kameleoon.data.manager.visitor_slot import VisitorSlot
@@ -77,9 +77,10 @@ class VisitorManager:
         data_to_add: List[Any] = [None] * len(args)
         for i, data in enumerate(args):
             if isinstance(data, CustomData):
-                data_to_add[i] = self.__process_custom_data(visitor_code, visitor, custom_data_info, data)
-            else:
-                data_to_add[i] = data
+                data = self.__process_custom_data(visitor_code, visitor, custom_data_info, data)
+            elif isinstance(data, Conversion):
+                data = self.__process_conversion(data, custom_data_info)
+            data_to_add[i] = data
         visitor.add_data(*data_to_add)
         KameleoonLogger.debug("RETURN: VisitorManager.add_data(visitor_code: %s, args: %s) -> (visitor)",
                               visitor_code, args)
@@ -89,11 +90,11 @@ class VisitorManager:
         self, visitor_code: str, visitor: Visitor, custom_data_info: CustomDataInfo, custom_data: 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)
+        if mapped_cd := self.__try_map_custom_data_index_by_name(custom_data, custom_data_info):
+            custom_data = mapped_cd
+        else:
+            KameleoonLogger.error("%s is invalid and will be ignored", custom_data)
+            return None
         # We shouldn't send custom data with local only type
         if custom_data_info.is_local_only(custom_data.index):
             custom_data.mark_as_sent()
@@ -113,6 +114,28 @@ class VisitorManager:
             return MappingIdentifier(custom_data)
         return custom_data
 
+    @staticmethod
+    def __process_conversion(conversion: Conversion, cdi: CustomDataInfo) -> Conversion:
+        if conversion.metadata:
+            metadata = []
+            for cd in conversion.metadata:
+                mapped_cd = VisitorManager.__try_map_custom_data_index_by_name(cd, cdi)
+                if mapped_cd:
+                    metadata.append(mapped_cd)
+                else:
+                    KameleoonLogger.warning("Conversion metadata %s is invalid", cd)
+            conversion._metadata = metadata
+        return conversion
+
+    @staticmethod
+    def __try_map_custom_data_index_by_name(custom_data: CustomData, cdi: CustomDataInfo) -> Optional[CustomData]:
+        if custom_data.index != CustomData.UNDEFINED_INDEX:
+            return custom_data
+        if custom_data.name is None:
+            return None
+        cd_index = cdi.get_custom_data_index_by_name(custom_data.name)
+        return custom_data._named_to_indexed(cd_index) if cd_index is not None else None
+
     def __purge(self) -> None:
         KameleoonLogger.debug("CALL: VisitorManager.__purge()")
         expired_time = time.time() - self.__expiration_period

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/data/personalization.py

@@ -13,7 +13,7 @@ class Personalization(BaseData):
         self.__variation_id = variation_id
 
     @property
-    def id(self) -> int:  # pylint: disable=C0103
+    def id(self) -> int:
         """Returns personalization ID"""
         return self.__id
 

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/data/targeted_segment.py

@@ -13,7 +13,7 @@ class TargetedSegment(BaseData, DuplicationUnsafeSendableBase):
         self.__id = id_
 
     @property
-    def id(self) -> int:  # pylint: disable=C0103
+    def id(self) -> int:
         """Returns the segment ID."""
         return self.__id
 

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/exceptions.py

@@ -1,7 +1,5 @@
 """Kameleoon exceptions"""
 
-from typing import Optional
-
 
 class KameleoonError(Exception):
     """Base Kameleoon error"""
@@ -53,11 +51,6 @@ class FeatureVariationNotFound(NotFoundError):
 class FeatureEnvironmentDisabled(FeatureError):
     """Exception indicating that feature flag is disabled for the visitor's current environment."""
 
-    def __init__(self, feature_key: str, environment: Optional[str] = None) -> None:
-        env = "default" if environment is None else f"'{environment}'"
-        message = f"Feature '{feature_key}' is disabled for {env} environment"
-        super().__init__(message)
-
 
 class FeatureNotFound(NotFoundError):
     """Exception indicating that the requested feature ID

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/helpers/functions.py

@@ -16,7 +16,7 @@ def get_size(obj) -> float:
     return sum([sys.getsizeof(v) + sys.getsizeof(k) for k, v in obj.items()])
 
 
-E = TypeVar('E', bound=Enum)  # pylint: disable=C0103
+E = TypeVar('E', bound=Enum)
 
 
 def enum_from_literal(literal: str, enum_type: Type[E], default_value: E) -> E:

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/kameleoon_client.py

@@ -7,6 +7,7 @@ from kameleoon.client_readiness.async_readiness import AsyncClientReadiness
 from kameleoon.client_readiness.threading_readiness import ThreadingClientReadiness
 
 from kameleoon import configuration
+from kameleoon.configuration.consent_blocking_behaviour import ConsentBlockingBehaviour
 from kameleoon.configuration.data_file import DataFile
 from kameleoon.configuration.feature_flag import FeatureFlag
 from kameleoon.configuration.rule import Rule
@@ -15,6 +16,7 @@ from kameleoon.configuration.rule_type import RuleType
 from kameleoon.data import Conversion, CustomData, Data, UniqueIdentifier
 from kameleoon.data.manager.assigned_variation import AssignedVariation
 from kameleoon.data.manager.forced_experiment_variation import ForcedExperimentVariation
+from kameleoon.data.manager.legal_consent import LegalConsent
 from kameleoon.data.manager.visitor import Visitor
 from kameleoon.data.manager.visitor_manager import VisitorManager
 from kameleoon.data.targeted_segment import TargetedSegment
@@ -312,7 +314,7 @@ class KameleoonClient:
         )
         validate_visitor_code(visitor_code)
         visitor = self._visitor_manager.get_or_create_visitor(visitor_code)
-        visitor.legal_consent = consent
+        visitor.legal_consent = LegalConsent.GIVEN if consent else LegalConsent.NOT_GIVEN
         if cookies is not None:
             self._cookie_manager.update(visitor_code, consent, cookies)
         KameleoonLogger.info(
@@ -356,8 +358,13 @@ 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,
-        negative=False, metadata: Optional[Iterable[CustomData]] = 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
@@ -383,7 +390,12 @@ class KameleoonClient:
         KameleoonLogger.info(
             "CALL: KameleoonClient.track_conversion(visitor_code: %s, goal_id: %s, revenue: %s, "
             "is_unique_identifier: %s, negative: %s, metadata: %s)",
-            visitor_code, goal_id, revenue, is_unique_identifier, negative, metadata
+            visitor_code,
+            goal_id,
+            revenue,
+            is_unique_identifier,
+            negative,
+            metadata,
         )
         validate_visitor_code(visitor_code)
         if is_unique_identifier is not None:
@@ -393,7 +405,12 @@ class KameleoonClient:
         KameleoonLogger.info(
             "RETURN: KameleoonClient.track_conversion(visitor_code: %s, goal_id: %s, revenue: %s, "
             "is_unique_identifier: %s, negative: %s, metadata: %s)",
-            visitor_code, goal_id, revenue, is_unique_identifier, negative, metadata
+            visitor_code,
+            goal_id,
+            revenue,
+            is_unique_identifier,
+            negative,
+            metadata,
         )
 
     def flush(
@@ -619,7 +636,10 @@ class KameleoonClient:
         for feature_flag in self._data_manager.data_file.feature_flags.values():
             if not feature_flag.environment_enabled:
                 continue
-            variation_key, eval_exp = self.__get_variation_info(visitor_code, feature_flag, track)
+            try:
+                variation_key, eval_exp = self.__get_variation_info(visitor_code, feature_flag, track)
+            except FeatureEnvironmentDisabled:
+                continue
             if only_active and (variation_key == configuration.Variation.Type.OFF.value):
                 continue
             variations[feature_flag.feature_key] = self.__create_external_variation(
@@ -731,7 +751,11 @@ class KameleoonClient:
         in_holdout_variation_key = "in-holdout"
         KameleoonLogger.debug(
             "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
+            "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, bucketing_cd_index)
@@ -746,7 +770,11 @@ class KameleoonClient:
         KameleoonLogger.debug(
             "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
+            visitor_code,
+            track,
+            save,
+            bucketing_cd_index,
+            is_not_in_holdout,
         )
         return is_not_in_holdout
 
@@ -1163,7 +1191,10 @@ class KameleoonClient:
         def filter_conditions(feature_flag: FeatureFlag) -> bool:
             if not feature_flag.environment_enabled:
                 return False
-            eval_exp = self.__evaluate(visitor, visitor_code, feature_flag, False, False)
+            try:
+                eval_exp = self.__evaluate(visitor, visitor_code, feature_flag, False, False)
+            except FeatureEnvironmentDisabled:
+                return False
             variation_key = self.__calculate_variation_key(eval_exp, feature_flag.default_variation_key)
             return variation_key != configuration.Variation.Type.OFF.value
 
@@ -1211,7 +1242,10 @@ class KameleoonClient:
         for feature_flag in self._data_manager.data_file.feature_flags.values():
             if not feature_flag.environment_enabled:
                 continue
-            eval_exp = self.__evaluate(visitor, visitor_code, feature_flag, False, False)
+            try:
+                eval_exp = self.__evaluate(visitor, visitor_code, feature_flag, False, False)
+            except FeatureEnvironmentDisabled:
+                continue
             variation_key = self.__calculate_variation_key(eval_exp, feature_flag.default_variation_key)
             if variation_key == configuration.Variation.Type.OFF.value:
                 continue
@@ -1437,7 +1471,7 @@ class KameleoonClient:
                     data_file = DataFile.from_json(
                         self._config.environment,
                         fetched_configuration.last_modified,
-                        fetched_configuration.configuration
+                        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)
@@ -1547,7 +1581,8 @@ class KameleoonClient:
         fetched_configuration = await service.fetch_configuration(self._config.environment, time_stamp, last_modified)
         KameleoonLogger.debug(
             "RETURN: KameleoonClient._obtain_configuration(time_stamp: %s) -> (fetched_configuration: %s)",
-            time_stamp, fetched_configuration
+            time_stamp,
+            fetched_configuration,
         )
         return fetched_configuration
 
@@ -1615,7 +1650,9 @@ class KameleoonClient:
             return None
         KameleoonLogger.debug(
             "CALL: KameleoonClient.__evaluate_cbscores(visitor, visitor_code: %s, rule: %s, bucketing_cd_index: %s)",
-            visitor_code, rule, bucketing_cd_index
+            visitor_code,
+            rule,
+            bucketing_cd_index,
         )
         eval_exp = None
         var_id_group_by_scores = visitor.cbscores.values.get(rule.experiment.id_)
@@ -1640,11 +1677,15 @@ class KameleoonClient:
                 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, bucketing_cd_index: %s)"
-            " -> (eval_exp: %s)", visitor_code, rule, bucketing_cd_index, eval_exp
+            " -> (eval_exp: %s)",
+            visitor_code,
+            rule,
+            bucketing_cd_index,
+            eval_exp,
         )
         return eval_exp
 
-    def __calculate_variation_rule_for_feature(
+    def __calculate_variation_rule_for_feature(  # noqa: C901, pylint: disable=R0912
         self, visitor_code: str, feature_flag: FeatureFlag
     ) -> Optional[EvaluatedExperiment]:
         """helper method for calculate variation key for feature flag"""
@@ -1654,6 +1695,11 @@ class KameleoonClient:
             feature_flag,
         )
         visitor = self._visitor_manager.get_visitor(visitor_code)
+        datafile = self._data_manager.data_file
+        if datafile.settings.is_consent_required:
+            consent = visitor.legal_consent if visitor else LegalConsent.UNKNOWN
+        else:
+            consent = LegalConsent.GIVEN
         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:
@@ -1669,11 +1715,20 @@ class KameleoonClient:
                 # Forcing experiment variation in targeting-only mode
                 eval_exp = EvaluatedExperiment.from_var_by_exp_rule(forced_variation.var_by_exp, rule)
                 break
-            # uses for rule exposition
+            # used for rule exposition
             hash_rule = Hasher.obtain(code_for_hash, rule.id_, rule.respool_time)
             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:
+                # Checking if the evaluation is blocked due to the consent policy
+                if (consent == LegalConsent.NOT_GIVEN) and rule.is_experimentation:
+                    blocking_behaviour = datafile.settings.blocking_behaviour_if_consent_not_given
+                    if blocking_behaviour == ConsentBlockingBehaviour.PARTIALLY_BLOCKED:
+                        break
+                    raise FeatureEnvironmentDisabled(
+                        f"Evaluation of {rule} is blocked because consent is not provided for visitor '{visitor_code}'"
+                    )
+                # Checking cbs
                 eval_exp = self.__evaluate_cbscores(
                     visitor, visitor_code, rule, feature_flag.bucketing_custom_data_index
                 )
@@ -1683,8 +1738,7 @@ class KameleoonClient:
                     if rule.experiment.first_variation:
                         eval_exp = EvaluatedExperiment.from_var_by_exp_rule(rule.experiment.first_variation, rule)
                     break
-
-                # uses for variation's expositions
+                # used for variation's expositions
                 hash_variation = Hasher.obtain(code_for_hash, rule.experiment.id_, rule.respool_time)
                 KameleoonLogger.debug("Calculated variation hash %s for code %s", hash_variation, code_for_hash)
                 # get variation with hash_variation
@@ -1727,7 +1781,7 @@ class KameleoonClient:
         return (
             not self._data_manager.data_file.settings.is_consent_required
             or ((visitor := self._visitor_manager.get_visitor(visitor_code)) is not None)
-            and visitor.legal_consent
+            and (visitor.legal_consent == LegalConsent.GIVEN)
         )
 
     def set_forced_variation(

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/managers/tracking/tracking_builder.py

@@ -3,6 +3,7 @@ from typing import Iterable, List, Optional, Tuple
 from kameleoon.configuration.data_file import DataFile
 from kameleoon.configuration.rule_type import RuleType
 from kameleoon.data.custom_data import CustomData
+from kameleoon.data.manager.legal_consent import LegalConsent
 from kameleoon.data.manager.visitor import Visitor
 from kameleoon.data.manager.visitor_manager import VisitorManager
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
@@ -86,7 +87,9 @@ class TrackingBuilder:
             visitor_code, is_consent_given)
 
     def __is_consent_given(self, visitor: Optional[Visitor]) -> bool:
-        return not self.__data_file.settings.is_consent_required or ((visitor is not None) and visitor.legal_consent)
+        return not self.__data_file.settings.is_consent_required or (
+            (visitor is not None) and (visitor.legal_consent == LegalConsent.GIVEN)
+        )
 
     def __collect_tracking_data(
         self, visitor_code: str, visitor: Optional[Visitor], is_consent_given: bool

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/network/cookie/cookie_manager.py

@@ -74,13 +74,13 @@ class CookieManager:
         if default_visitor_code is None:
             visitor_code = generate_visitor_code()
             KameleoonLogger.debug("Generated new visitor code %s", visitor_code)
-            if not self._data_manager.is_visitor_code_managed and cookies is not None:
+            if not self._data_manager.is_visitor_code_managed and (cookies is not None):
                 self._add(visitor_code, cookies)
             return visitor_code
         validate_visitor_code(default_visitor_code)
         visitor_code = default_visitor_code
         KameleoonLogger.debug("Used default visitor code '%s'", default_visitor_code)
-        if cookies is not None:
+        if not self._data_manager.is_visitor_code_managed and (cookies is not None):
             self._add(visitor_code, cookies)
         return visitor_code
 
@@ -90,8 +90,6 @@ class CookieManager:
                               visitor_code, consent, cookies)
         if consent:
             self._add(visitor_code, cookies)
-        else:
-            self._remove(cookies)
         KameleoonLogger.debug("RETURN: CookieManager.update(visitor_code: %s, consent: %s, cookies: %s)",
                               visitor_code, consent, cookies)
 
@@ -107,15 +105,6 @@ class CookieManager:
         cookies[VISITOR_CODE_COOKIE] = morsel
         KameleoonLogger.debug("RETURN: CookieManager._add(visitor_code: %s, cookies: %s)", visitor_code, cookies)
 
-    def _remove(self, cookies: Dict[str, Morsel[str]]) -> None:
-        KameleoonLogger.debug("CALL: CookieManager._remove(cookies: %s)", cookies)
-        if self._data_manager.is_visitor_code_managed:
-            if morsel := cookies.get(VISITOR_CODE_COOKIE):
-                morsel["domain"] = self._top_level_domain
-                morsel["path"] = "/"
-                morsel["max-age"] = "0"
-        KameleoonLogger.debug("RETURN: CookieManager._remove(cookies: %s)", cookies)
-
     def _process_simulated_variations(
         self, cookies_readonly: Optional[Dict[str, str]], cookies: Optional[Dict[str, Morsel[str]]], visitor_code: str
     ) -> None:

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/network/network_manager.py

@@ -7,7 +7,7 @@ from kameleoon.network.service_initialize_context import ServiceInitializeContex
 from kameleoon.network.services.service import Service
 
 
-S = TypeVar("S", bound=Service)  # pylint: disable=C0103
+S = TypeVar("S", bound=Service)
 
 
 class NetworkManager:

{kameleoon_client_python-3.16.2 → kameleoon_client_python-3.17.0}/kameleoon/sdk_version.py

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