kameleoon-client-python 3.6.0__tar.gz → 3.7.0__tar.gz

{kameleoon-client-python-3.6.0 → kameleoon-client-python-3.7.0}/PKG-INFO

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

{kameleoon-client-python-3.6.0 → kameleoon-client-python-3.7.0}/kameleoon/configuration/data_file.py

@@ -56,6 +56,7 @@ class DataFile:
         )
         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()
         self.__collect_indices()
@@ -84,6 +85,11 @@ class DataFile:
         """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"""
+        return self.__rule_info_by_exp_id
+
     @property
     def variation_by_id(self) -> Dict[int, VariationByExposition]:
         """Returns dictionary of all variations stored by id"""
@@ -122,6 +128,7 @@ class DataFile:
                 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)
                     for variation in rule.variation_by_exposition:
@@ -146,3 +153,20 @@ class DataFile:
             f"settings:{self.__settings}"
             f"}}"
         )
+
+    class RuleInfo:
+        """Aggregates some information related to a specific rule"""
+
+        def __init__(self, feature_flag: FeatureFlag, rule: Rule) -> None:
+            self.__feature_flag = feature_flag
+            self.__rule = rule
+
+        @property
+        def feature_flag(self) -> FeatureFlag:
+            """Returns the feature flag"""
+            return self.__feature_flag
+
+        @property
+        def rule(self) -> Rule:
+            """Returns the rule"""
+            return self.__rule

{kameleoon-client-python-3.6.0 → kameleoon-client-python-3.7.0}/kameleoon/configuration/rule.py

@@ -3,6 +3,7 @@
 from typing import Any, List, Dict, Optional
 from kameleoon.configuration.rule_type import RuleType, rule_type_from_literal
 from kameleoon.configuration.variation_by_exposition import VariationByExposition
+from kameleoon.exceptions import FeatureVariationNotFound
 from kameleoon.targeting.models import Segment
 
 
@@ -43,6 +44,16 @@ class Rule:
                 return var_by_exp
         return None
 
+    def get_variation_by_key(self, variation_key: str) -> VariationByExposition:
+        """
+        Finds variation with a passed variation key.
+        Raises the `FeatureVariationNotFound` exception if such variation does not exist.
+        """
+        for var_by_exp in self.variation_by_exposition:
+            if var_by_exp.variation_key == variation_key:
+                return var_by_exp
+        raise FeatureVariationNotFound("'#{variation_key}'")
+
     @property
     def is_experimentation(self) -> bool:
         """Return `true` if rule is `experimentation` type"""

{kameleoon-client-python-3.6.0 → kameleoon-client-python-3.7.0}/kameleoon/data/data.py

@@ -20,6 +20,8 @@ class DataType(IntEnum):
     VISITOR_VISITS = 11
     KCS_HEAT = 12
     UNIQUE_IDENTIFIER = 13
+    FORCED_EXPERIMENT_VARIATION = 14
+    FORCED_FEATURE_VARIATION = 15
 
 
 class BaseData:

kameleoon-client-python-3.7.0/kameleoon/data/manager/forced_experiment_variation.py

@@ -0,0 +1,49 @@
+"""Forced Experiment Variation"""
+
+from typing import Any, cast
+from kameleoon.configuration.rule import Rule
+from kameleoon.configuration.variation_by_exposition import VariationByExposition
+from kameleoon.data.data import DataType
+from kameleoon.data.manager.forced_variation import ForcedVariation
+
+
+class ForcedExperimentVariation(ForcedVariation):
+    """Represents a forced experiment variation"""
+
+    def __init__(
+        self, rule: Rule, var_by_exp: VariationByExposition, force_targeting: bool
+    ) -> None:
+        super().__init__(rule, var_by_exp)
+        self.__force_targeting = force_targeting
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.FORCED_EXPERIMENT_VARIATION
+
+    @property
+    def rule(self) -> Rule:
+        """Returns the rule"""
+        return self._rule or cast(Rule, self._rule)
+
+    @property
+    def var_by_exp(self) -> VariationByExposition:
+        """Returns the variation by exposition"""
+        return self._var_by_exp or cast(VariationByExposition, self._var_by_exp)
+
+    @property
+    def force_targeting(self) -> bool:
+        """Returns the force targeting flag's state"""
+        return self.__force_targeting
+
+    def __eq__(self, value: Any) -> bool:
+        return super().__eq__(value) and isinstance(value, ForcedExperimentVariation) and \
+            (self.__force_targeting == value.force_targeting)
+
+    def __str__(self) -> str:
+        return (
+            "ForcedExperimentVariation{"
+            f"rule:{self._rule},"
+            f"var_by_exp:{self._var_by_exp},"
+            f"force_targeting:{self.__force_targeting},"
+            "}"
+        )

kameleoon-client-python-3.7.0/kameleoon/data/manager/forced_feature_variation.py

@@ -0,0 +1,46 @@
+"""Forced Feature Variation"""
+
+from typing import Any, Optional
+from kameleoon.configuration.rule import Rule
+from kameleoon.configuration.variation_by_exposition import VariationByExposition
+from kameleoon.data.data import DataType
+from kameleoon.data.manager.forced_variation import ForcedVariation
+
+
+class ForcedFeatureVariation(ForcedVariation):
+    """Represents a forced feature variation"""
+
+    def __init__(
+        self, feature_key: str, rule: Optional[Rule], var_by_exp: Optional[VariationByExposition], simulated: bool
+    ) -> None:
+        super().__init__(rule, var_by_exp)
+        self.__feature_key = feature_key
+        self.__simulated = simulated
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.FORCED_FEATURE_VARIATION
+
+    @property
+    def feature_key(self) -> str:
+        """Returns the feature key"""
+        return self.__feature_key
+
+    @property
+    def simulated(self) -> bool:
+        """Returns the simulated flag's state"""
+        return self.__simulated
+
+    def __eq__(self, value: Any) -> bool:
+        return super().__eq__(value) and isinstance(value, ForcedFeatureVariation) and \
+            (self.__feature_key == value.feature_key) and (self.__simulated == value.simulated)
+
+    def __str__(self) -> str:
+        return (
+            "ForcedFeatureVariation{"
+            f"feature_key:'{self.__feature_key}',"
+            f"rule:{self._rule},"
+            f"var_by_exp:{self._var_by_exp},"
+            f"simulated:{self.__simulated},"
+            "}"
+        )

kameleoon-client-python-3.7.0/kameleoon/data/manager/forced_variation.py

@@ -0,0 +1,33 @@
+"""Forced Variation"""
+
+from typing import Any, Optional
+from kameleoon.configuration.rule import Rule
+from kameleoon.configuration.variation_by_exposition import VariationByExposition
+from kameleoon.data.data import BaseData, DataType
+
+
+class ForcedVariation(BaseData):
+    """Represents a forced variation"""
+
+    def __init__(self, rule: Optional[Rule], var_by_exp: Optional[VariationByExposition]) -> None:
+        super().__init__()
+        self._rule = rule
+        self._var_by_exp = var_by_exp
+
+    @property
+    def data_type(self) -> DataType:
+        raise NotImplementedError
+
+    @property
+    def rule(self) -> Optional[Rule]:
+        """Returns the rule"""
+        return self._rule
+
+    @property
+    def var_by_exp(self) -> Optional[VariationByExposition]:
+        """Returns the variation by exposition"""
+        return self._var_by_exp
+
+    def __eq__(self, value: Any) -> bool:
+        return isinstance(value, ForcedVariation) and \
+            (self._rule == value._rule) and (self._var_by_exp == value._var_by_exp)

{kameleoon-client-python-3.6.0 → kameleoon-client-python-3.7.0}/kameleoon/data/manager/visitor.py

@@ -1,6 +1,6 @@
 """Visitor"""
 from threading import Lock
-from typing import Any, Callable, Optional, Dict, List, Iterator, cast
+from typing import Any, Callable, Optional, Dict, List, Iterator, Iterable, cast
 
 from kameleoon.data.visitor_visits import VisitorVisits
 from kameleoon.data.data import Data
@@ -17,6 +17,8 @@ from kameleoon.data.page_view import PageView
 from kameleoon.data.unique_identifier import UniqueIdentifier
 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.page_view_visit import PageViewVisit
 from kameleoon.logging.kameleoon_logger import KameleoonLogger
 from kameleoon.network.sendable import Sendable
@@ -26,7 +28,7 @@ EMPTY_DICT: Dict[Any, Any] = {}
 EMPTY_LIST: List[Any] = []
 
 
-class Visitor:
+class Visitor:  # pylint: disable=R0904
     """Visitor"""
     def __init__(self, source: Optional["Visitor"] = None) -> None:
         if source is None:
@@ -124,6 +126,45 @@ class Visitor:
         KameleoonLogger.debug('CALL/RETURN: Visitor.variations -> (variations: %s)', variations)
         return variations
 
+    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.
+        Otherwise returns `None`.
+        """
+        KameleoonLogger.debug('CALL: Visitor.get_forced_feature_variation(feature_key: %s)', feature_key)
+        ffv = self._data.simulated_variations.get(feature_key) if self._data.simulated_variations else None
+        KameleoonLogger.debug(
+            'RETURN: Visitor.get_forced_feature_variation(feature_key: %s) -> (variation: %s)', feature_key, ffv
+        )
+        return ffv
+
+    def get_forced_experiment_variation(self, experiment_id: int) -> Optional[ForcedExperimentVariation]:
+        """
+        Returns an associated forced experiment variation by its experiment id if it is present.
+        Otherwise returns `None`.
+        """
+        KameleoonLogger.debug('CALL: Visitor.get_forced_experiment_variation(experiment_id: %s)', experiment_id)
+        fev = self._data.forced_variations.get(experiment_id) if self._data.forced_variations else None
+        KameleoonLogger.debug(
+            'RETURN: Visitor.get_forced_experiment_variation(experiment_id: %s) -> (variation: %s)', experiment_id, fev
+        )
+        return fev
+
+    def reset_forced_experiment_variation(self, experiment_id: int) -> None:
+        """Resets an associated forced experiment variation for some experiment id"""
+        KameleoonLogger.debug('CALL: Visitor.reset_forced_experiment_variation(experiment_id: %s)', experiment_id)
+        if self._data.forced_variations:
+            self._data.forced_variations.pop(experiment_id, None)
+        KameleoonLogger.debug('RETURN: Visitor.reset_forced_experiment_variation(experiment_id: %s)', experiment_id)
+
+    def update_simulated_variations(self, variations: Iterable[ForcedFeatureVariation]) -> None:
+        """Updates the associated simulated variations"""
+        if not (self._data.simulated_variations or variations):
+            return
+        KameleoonLogger.debug('CALL: Visitor.update_simulated_variations(variations: %s)', variations)
+        self._data.simulated_variations = {sv.feature_key: sv for sv in variations}
+        KameleoonLogger.debug('RETURN: Visitor.update_simulated_variations(variations: %s)', variations)
+
     @property
     def kcs_heat(self) -> Optional[KcsHeat]:
         """Returns the KCS heat data associated with this Visitor."""
@@ -217,6 +258,8 @@ class Visitor:
             self.page_view_visits: Optional[Dict[str, PageViewVisit]] = None
             self.conversions: Optional[List[Conversion]] = None
             self.variations: Optional[Dict[int, AssignedVariation]] = None
+            self.forced_variations: Optional[Dict[int, ForcedExperimentVariation]] = None
+            self.simulated_variations: Optional[Dict[str, ForcedFeatureVariation]] = None
             self.kcs_heat: Optional[KcsHeat] = None
             self.visitor_visits: Optional[VisitorVisits] = None
             self.mapping_identifier: Optional[str] = None
@@ -294,6 +337,18 @@ class Visitor:
         if context.overwrite or variation.experiment_id not in self.variations:
             self._data.variations[variation.experiment_id] = variation
 
+    def _add_forced_feature_variation(self, context: DataAddingContext) -> None:
+        ffv = cast(ForcedFeatureVariation, context.data)
+        if self._data.simulated_variations is None:
+            self._data.simulated_variations = {}
+        self._data.simulated_variations[ffv.feature_key] = ffv
+
+    def _add_forced_experiment_variation(self, context: DataAddingContext) -> None:
+        fev = cast(ForcedExperimentVariation, context.data)
+        if self._data.forced_variations is None:
+            self._data.forced_variations = {}
+        self._data.forced_variations[fev.rule.experiment_id] = fev
+
     def _set_browser(self, context: DataAddingContext) -> None:
         if context.overwrite or self._data.browser is None:
             self._data.browser = cast(Browser, context.data)
@@ -372,5 +427,7 @@ class Visitor:
         KcsHeat: _set_kcs_heat,
         VisitorVisits: _set_visitor_visits,
         AssignedVariation: _add_variation,
+        ForcedFeatureVariation: _add_forced_feature_variation,
+        ForcedExperimentVariation: _add_forced_experiment_variation,
         UniqueIdentifier: _set_is_unique_identifier,
     }

{kameleoon-client-python-3.6.0 → kameleoon-client-python-3.7.0}/kameleoon/exceptions.py

@@ -70,6 +70,15 @@ class FeatureNotFound(NotFoundError):
         super().__init__(self.message)
 
 
+class FeatureExperimentNotFound(NotFoundError):  # //~ Derived from FeatureError in other SDKs
+    """Exception indicating that the requested experiment has not been found.
+    Check that the experiment's ID matches the provided one."""
+
+    def __init__(self, message=None) -> None:
+        self.message = "Experiment " + str(message)
+        super().__init__(self.message)
+
+
 class FeatureVariableNotFound(NotFoundError):
     """Exception indicating that the requested variable has not been found.
     Check that the variable's ID (or key) matches the one in your code."""

{kameleoon-client-python-3.6.0 → kameleoon-client-python-3.7.0}/kameleoon/helpers/domain.py

@@ -9,6 +9,7 @@ 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:
@@ -35,8 +36,10 @@ def validate_top_level_domain(top_level_domain: str) -> str:
                 protocol, top_level_domain)
             break
 
-    if not re.match(REGEX_DOMAIN, top_level_domain):
-        KameleoonLogger.error(f"The top-level domain '{top_level_domain}' is invalid.")
-        return ""
+    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

{kameleoon-client-python-3.6.0 → kameleoon-client-python-3.7.0}/kameleoon/kameleoon_client.py

@@ -14,10 +14,12 @@ from kameleoon.configuration.variation_by_exposition import VariationByExpositio
 
 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.visitor_manager import VisitorManager
 
 from kameleoon.exceptions import (
     FeatureVariationNotFound,
+    FeatureExperimentNotFound,
     FeatureVariableNotFound,
     FeatureEnvironmentDisabled,
     SiteCodeIsEmpty,
@@ -130,7 +132,7 @@ class KameleoonClient:
         )
         self._hybrid_manager = HybridManagerImpl(HYBRID_EXPIRATION_TIME, self._data_manager)
 
-        self._cookie_manager = CookieManager(self._data_manager, config.top_level_domain)
+        self._cookie_manager = CookieManager(self._data_manager, self._visitor_manager, config.top_level_domain)
         atsf = AccessTokenSourceFactory(config.client_id, config.client_secret)
         self._network_manager = self._network_manager_factory.create(
             self.site_code,
@@ -589,9 +591,13 @@ class KameleoonClient:
             "CALL: KameleoonClient.__get_variation_info(visitor_code: %s, feature_flag: %s, track: %s)",
             visitor_code, feature_flag, track
         )
-        var_by_exp, rule = self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
+        visitor = self._visitor_manager.get_visitor(visitor_code)
+        forced_variation = visitor.get_forced_feature_variation(feature_flag.feature_key) if visitor else None
+        var_by_exp, rule = (forced_variation.var_by_exp, forced_variation.rule) if forced_variation else \
+            self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
+        if not (forced_variation and forced_variation.simulated):
+            self.__save_variation(visitor_code, rule, var_by_exp, track)
         variation_key = self.__calculate_variation_key(var_by_exp, rule, feature_flag)
-        self.__save_variation(visitor_code, rule, var_by_exp, track)
         KameleoonLogger.debug(
             "RETURN: KameleoonClient.__get_variation_info(visitor_code: %s, feature_flag: %s, track: %s)"
             " -> (variation_key: %s, variation_by_exposition: %s, rule: %s)",
@@ -942,11 +948,14 @@ class KameleoonClient:
             "Call to deprecated function `get_active_feature_list_for_visitor`. "
             "Please use `get_active_features` instead."
         )
+        visitor = self._visitor_manager.get_visitor(visitor_code)
 
         def filter_conditions(feature_flag: FeatureFlag) -> bool:
             if not feature_flag.environment_enabled:
                 return False
-            (variation, rule) = self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
+            forced_variation = visitor.get_forced_feature_variation(feature_flag.feature_key) if visitor else None
+            variation, rule = (forced_variation.var_by_exp, forced_variation.rule) if forced_variation else \
+                self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
             variation_key = self.__calculate_variation_key(variation, rule, feature_flag)
             return variation_key != configuration.Variation.Type.OFF.value
 
@@ -987,11 +996,14 @@ class KameleoonClient:
         )
         KameleoonLogger.info("CALL: KameleoonClient.get_active_features(visitor_code: %s)", visitor_code)
         validate_visitor_code(visitor_code)
+        visitor = self._visitor_manager.get_visitor(visitor_code)
         map_active_features: Dict[str, Variation] = {}
         for feature_flag in self._data_manager.data_file.feature_flags.values():
             if not feature_flag.environment_enabled:
                 continue
-            (var_by_exp, rule) = self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
+            forced_variation = visitor.get_forced_feature_variation(feature_flag.feature_key) if visitor else None
+            var_by_exp, rule = (forced_variation.var_by_exp, forced_variation.rule) if forced_variation else \
+                self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
             variation_key = self.__calculate_variation_key(var_by_exp, rule, feature_flag)
             if variation_key == configuration.Variation.Type.OFF.value:
                 continue
@@ -1303,9 +1315,13 @@ class KameleoonClient:
             "CALL: KameleoonClient.__get_feature_variation_key(visitor_code: %s, feature_key: %s)",
             visitor_code, feature_key)
         feature_flag = self._data_manager.data_file.get_feature_flag(feature_key)
-        (variation, rule) = self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
+        visitor = self._visitor_manager.get_visitor(visitor_code)
+        forced_variation = visitor.get_forced_feature_variation(feature_key) if visitor else None
+        variation, rule = (forced_variation.var_by_exp, forced_variation.rule) if forced_variation else \
+            self.__calculate_variation_rule_for_feature(visitor_code, feature_flag)
+        if not (forced_variation and forced_variation.simulated):
+            self.__save_variation(visitor_code, rule, variation)
         variation_key = self.__calculate_variation_key(variation, rule, feature_flag)
-        self.__save_variation(visitor_code, rule, variation)
         self._tracking_manager.add_visitor_code(visitor_code)
         KameleoonLogger.debug(
             "RETURN: KameleoonClient.__get_feature_variation_key(visitor_code: %s, feature_key: %s) -> "
@@ -1338,28 +1354,36 @@ class KameleoonClient:
         KameleoonLogger.debug(
             "CALL: KameleoonClient.__calculate_variation_rule_for_feature(visitor_code: %s, feature_flag: %s)",
             visitor_code, feature_flag)
+        visitor = self._visitor_manager.get_visitor(visitor_code)
+        # use mappingIdentifier instead of visitorCode if it was set up
+        code_for_hash = (
+            visitor.mapping_identifier
+            if visitor is not None and visitor.mapping_identifier is not None
+            else visitor_code
+        )
+        selected_variation = None
+        selected_rule = None
         for rule in feature_flag.rules:
+            forced_variation = visitor.get_forced_experiment_variation(rule.experiment_id) if visitor else None
+            if forced_variation and forced_variation.force_targeting:
+                # Forcing experiment variation in force-targeting mode
+                selected_variation, selected_rule = forced_variation.var_by_exp, rule
+                break
             # check if visitor is targeted for rule, else next rule
             if not self.__check_targeting(visitor_code, rule.experiment_id, rule):
                 continue
-            visitor = self._visitor_manager.get_visitor(visitor_code)
-            # use mappingIdentifier instead of visitorCode if it was set up
-            code_for_hash = (
-                visitor.mapping_identifier
-                if visitor is not None and visitor.mapping_identifier is not None
-                else visitor_code
-            )
+            if forced_variation:
+                # Forcing experiment variation in targeting-only mode
+                selected_variation, selected_rule = forced_variation.var_by_exp, rule
+                break
             # uses for rule exposition
             hash_rule = obtain_hash_double_rule(code_for_hash, rule.id_, rule.respool_time)
             KameleoonLogger.debug("Calculated hash_rule: %s for visitor_code: %s", hash_rule, code_for_hash)
             # check main expostion for rule with hashRule
             if hash_rule <= rule.exposition:
                 if rule.is_targeted_delivery:
-                    KameleoonLogger.debug(
-                        "RETURN: KameleoonClient.__calculate_variation_rule_for_feature(visitor_code: %s, "
-                        "feature_flag: %s) -> (variation: %s, rule: %s)",
-                        visitor_code, feature_flag, rule.first_variation, rule)
-                    return (rule.first_variation, rule)
+                    selected_variation, selected_rule = rule.first_variation, rule
+                    break
 
                 # uses for variation's expositions
                 hash_variation = obtain_hash_double_rule(code_for_hash, rule.experiment_id, rule.respool_time)
@@ -1368,17 +1392,14 @@ class KameleoonClient:
                 # get variation with hash_variation
                 variation = rule.get_variation(hash_variation)
                 if variation:
-                    KameleoonLogger.debug(
-                        "RETURN: KameleoonClient.__calculate_variation_rule_for_feature(visitor_code: %s, "
-                        "feature_flag: %s) -> (variation: %s, rule: %s)",
-                        visitor_code, feature_flag, variation, rule)
-                    return (variation, rule)
+                    selected_variation, selected_rule = variation, rule
+                    break
             elif rule.is_targeted_delivery:
                 break
         KameleoonLogger.debug(
             "RETURN: KameleoonClient.__calculate_variation_rule_for_feature(visitor_code: %s, feature_flag: %s) "
-            "-> (variation: None, rule: None)", visitor_code, feature_flag)
-        return None, None
+            "-> (variation: %s, rule: %s)", visitor_code, feature_flag, selected_variation, selected_rule)
+        return selected_variation, selected_rule
 
     @staticmethod
     def __calculate_variation_key(
@@ -1409,3 +1430,49 @@ class KameleoonClient:
     def _is_consent_given(self, visitor_code: str) -> bool:
         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
+
+    def set_forced_variation(
+        self, visitor_code: str, experiment_id: int, variation_key: Optional[str], force_targeting=True
+    ) -> None:
+        """
+        Sets or resets a forced variation for a visitor in a specific experiment,
+        so the experiment will be evaluated to the variation for the visitor.
+
+        In order to reset the forced variation set the `variation_key` parameter to `None`.
+        If the forced variation you want to reset does not exist, the method will have no effect.
+
+        :param visitor_code: The unique visitor code identifying the visitor.
+        :type visitor_code: str
+        :param experiment_id: The identifier of the experiment you want to set/reset the forced variation for.
+        :type experiment_id: int
+        :param variation_key: The identifier of the variation you want the experiment to be evaluated to. \
+            Set to `None` to reset the forced variation.
+        :type variation_key: Optional[str]
+        :param force_targeting: If `True`, the visitor will be targeted to the experiment regardless its conditions. \
+            Otherwise, the normal targeting logic will be preserved. Optional (defaults to `True`).
+        :type force_targeting: bool
+
+        :raises VisitorCodeInvalid: The provided **visitor code** is invalid.
+        :raises FeatureExperimentNotFound: The provided **experiment id** does not exist in the feature flag.
+        :raises FeatureVariationNotFound: The provided **variation key** does not belong to the experiment.
+        """
+        KameleoonLogger.info(
+            "CALL: KameleoonClient.set_forced_variation(visitor_code: %s, experiment_id: %s, variation_key: %s, "
+            "force_targeting: %s)", visitor_code, experiment_id, variation_key, force_targeting
+        )
+        validate_visitor_code(visitor_code)
+        if variation_key is None:
+            visitor = self._visitor_manager.get_visitor(visitor_code)
+            if visitor:
+                visitor.reset_forced_experiment_variation(experiment_id)
+        else:
+            rule_info = self._data_manager.data_file.rule_info_by_exp_id.get(experiment_id)
+            if rule_info is None:
+                raise FeatureExperimentNotFound(experiment_id)
+            var_by_exp = rule_info.rule.get_variation_by_key(variation_key)
+            forced_variation = ForcedExperimentVariation(rule_info.rule, var_by_exp, force_targeting)
+            self._visitor_manager.add_data(visitor_code, forced_variation)
+        KameleoonLogger.info(
+            "RETURN: KameleoonClient.set_forced_variation(visitor_code: %s, experiment_id: %s, variation_key: %s, "
+            "force_targeting: %s)", visitor_code, experiment_id, variation_key, force_targeting
+        )