Implement Ruby changes correctly

Author: esrakartalOpt

optimizely/decision_service.py

@@ -708,14 +708,14 @@ def get_decision_for_flag(
         user_id = user_context.user_id
 
         # Check holdouts
-        holdouts = project_config.get_holdouts_for_flag(feature_flag.id)
+        holdouts = project_config.get_holdouts_for_flag(feature_flag.key)
         for holdout in holdouts:
             holdout_decision = self.get_variation_for_holdout(holdout, user_context, project_config)
             reasons.extend(holdout_decision['reasons'])
 
             decision = holdout_decision['decision']
             # Check if user was bucketed into holdout (has a variation)
-            if decision is None or decision.variation is None:
+            if decision.variation is None:
                 continue
 
             message = (
@@ -905,9 +905,9 @@ def get_variation_for_holdout(
             self.logger.info(message)
             decide_reasons.append(message)
 
-            # Create Decision for holdout - pass holdout dict as experiment, source is HOLDOUT
+            # Create Decision for holdout - experiment is None, source is HOLDOUT
             holdout_decision: Decision = Decision(
-                experiment=holdout,  # type: ignore[arg-type]
+                experiment=None,
                 variation=variation,
                 source=enums.DecisionSources.HOLDOUT,
                 cmab_uuid=None
@@ -1017,7 +1017,7 @@ def get_variations_for_feature_list(
             ignore_ups = OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE in options
 
         user_profile_tracker: Optional[UserProfileTracker] = None
-        if not ignore_ups and self.user_profile_service:
+        if self.user_profile_service is not None and not ignore_ups:
             user_id = user_context.user_id
             user_profile_tracker = UserProfileTracker(user_id, self.user_profile_service, self.logger)
             user_profile_tracker.load_user_profile([], None)

optimizely/optimizely.py

@@ -15,7 +15,7 @@
 
 from typing import TYPE_CHECKING, Any, Optional, Union
 
-from optimizely.helpers.types import HoldoutDict, VariationDict
+from optimizely.helpers.types import VariationDict
 
 
 from . import decision_service
@@ -261,25 +261,6 @@ def _get_feature_enabled(self, variation: Optional[Union[entities.Variation, Var
         except (AttributeError, KeyError, TypeError):
             return False
 
-    def _get_experiment_key(self, experiment: Optional[Union[entities.Experiment, HoldoutDict]]) -> Optional[str]:
-        """Helper to extract experiment/holdout key from either dict or Experiment object.
-        Args:
-            experiment: Either a HoldoutDict (from holdout) or entities.Experiment object
-        Returns:
-            The experiment/holdout key as a string, or None if not available
-        """
-        if experiment is None:
-            return None
-
-        try:
-            if isinstance(experiment, dict):
-                return experiment.get('key')
-            else:
-                return experiment.key
-        except (AttributeError, KeyError, TypeError):
-            self.logger.warning(f"Unable to extract experiment key from {type(experiment)}")
-            return None
-
     def _validate_instantiation_options(self) -> None:
         """ Helper method to validate all instantiation parameters.
 
@@ -452,7 +433,7 @@ def _get_feature_variable_for_type(
         decision_result = self.decision_service.get_variation_for_feature(project_config, feature_flag, user_context)
         decision = decision_result['decision']
 
-        if decision and decision.variation:
+        if decision.variation:
 
             feature_enabled = self._get_feature_enabled(decision.variation)
             if feature_enabled:
@@ -474,7 +455,7 @@ def _get_feature_variable_for_type(
 
         if decision.source in (enums.DecisionSources.FEATURE_TEST, enums.DecisionSources.HOLDOUT):
             source_info = {
-                'experiment_key': self._get_experiment_key(decision.experiment),
+                'experiment_key': decision.experiment.key if decision.experiment else None,
                 'variation_key': self._get_variation_key(decision.variation),
             }
 
@@ -578,7 +559,7 @@ def _get_all_feature_variables_for_type(
 
         if decision.source == enums.DecisionSources.FEATURE_TEST:
             source_info = {
-                'experiment_key': self._get_experiment_key(decision.experiment),
+                'experiment_key': decision.experiment.key if decision.experiment else None,
                 'variation_key': self._get_variation_key(decision.variation),
             }
 
@@ -811,33 +792,30 @@ def is_feature_enabled(self, feature_key: str, user_id: str, attributes: Optiona
         user_context = OptimizelyUserContext(self, self.logger, user_id, attributes, False)
 
         decision = self.decision_service.get_variation_for_feature(project_config, feature, user_context)['decision']
-        cmab_uuid = decision.cmab_uuid if decision else None
+        cmab_uuid = decision.cmab_uuid
 
-        is_source_experiment = decision.source == enums.DecisionSources.FEATURE_TEST if decision else False
-        is_source_rollout = decision.source == enums.DecisionSources.ROLLOUT if decision else False
+        is_source_experiment = decision.source == enums.DecisionSources.FEATURE_TEST
+        is_source_rollout = decision.source == enums.DecisionSources.ROLLOUT
 
-        if decision and decision.variation:
+        if decision.variation:
             if self._get_feature_enabled(decision.variation) is True:
                 feature_enabled = True
 
-        if (decision and (is_source_rollout or not decision.variation) and
-                project_config.get_send_flag_decisions_value()):
+        if (is_source_rollout or not decision.variation) and project_config.get_send_flag_decisions_value():
             self._send_impression_event(
-                project_config, decision.experiment, decision.variation, feature.key,
-                self._get_experiment_key(decision.experiment) or '', str(decision.source), feature_enabled,
-                user_id, attributes, cmab_uuid
+                project_config, decision.experiment, decision.variation, feature.key, decision.experiment.key if
+                decision.experiment else '', str(decision.source), feature_enabled, user_id, attributes, cmab_uuid
             )
 
         # Send event if Decision came from an experiment.
-        if decision and is_source_experiment and decision.variation and decision.experiment:
+        if is_source_experiment and decision.variation and decision.experiment:
             source_info = {
-                'experiment_key': self._get_experiment_key(decision.experiment),
+                'experiment_key': decision.experiment.key,
                 'variation_key': self._get_variation_key(decision.variation),
             }
             self._send_impression_event(
-                project_config, decision.experiment, decision.variation, feature.key,
-                self._get_experiment_key(decision.experiment) or '', str(decision.source), feature_enabled,
-                user_id, attributes, cmab_uuid
+                project_config, decision.experiment, decision.variation, feature.key, decision.experiment.key,
+                str(decision.source), feature_enabled, user_id, attributes, cmab_uuid
             )
 
         if feature_enabled:
@@ -1266,17 +1244,17 @@ def _create_optimizely_decision(
     ) -> OptimizelyDecision:
         user_id = user_context.user_id
         feature_enabled = False
-        if flag_decision and flag_decision.variation is not None:
+        if flag_decision.variation is not None:
             if self._get_feature_enabled(flag_decision.variation):
                 feature_enabled = True
 
         self.logger.info(f'Feature {flag_key} is enabled for user {user_id} {feature_enabled}"')
 
         # Create Optimizely Decision Result.
         attributes = user_context.get_user_attributes()
-        rule_key = self._get_experiment_key(flag_decision.experiment) if flag_decision else None
+        rule_key = flag_decision.experiment.key if flag_decision.experiment else None
         all_variables = {}
-        decision_source = flag_decision.source if flag_decision else None
+        decision_source = flag_decision.source
         decision_event_dispatched = False
 
         feature_flag = project_config.feature_key_map.get(flag_key)

optimizely/project_config.py

@@ -833,55 +833,46 @@ def get_flag_variation(
 
         return None
 
-    def get_holdouts_for_flag(self, flag_key_or_id: str) -> list[HoldoutDict]:
+    def get_holdouts_for_flag(self, flag_key: str) -> list[HoldoutDict]:
         """ Helper method to get holdouts from an applied feature flag.
 
         Args:
-            flag_key_or_id: Key or ID of the feature flag.
-                           This parameter is required and should not be null/None.
+            flag_key: Key of the feature flag.
+                     This parameter is required and should not be null/None.
 
         Returns:
             The holdouts that apply for a specific flag.
         """
         if not self.holdouts:
             return []
 
-        # Check cache first (before validation, so we cache the validation result too)
-        if flag_key_or_id in self.flag_holdouts_map:
-            return self.flag_holdouts_map[flag_key_or_id]
-
-        # Find the flag by key or ID
-        flag_id = None
-        for flag in self.feature_flags:
-            if flag['id'] == flag_key_or_id or flag['key'] == flag_key_or_id:
-                flag_id = flag['id']
-                break
-
-        if flag_id is None:
-            # Cache the empty result for non-existent flags
-            self.flag_holdouts_map[flag_key_or_id] = []
+        # Get the feature flag to extract flag_id
+        feature = self.feature_key_map.get(flag_key)
+        if not feature:
             return []
 
+        flag_id = feature.id
+
+        # Check cache first (before validation, so we cache the validation result too)
+        if flag_id in self.flag_holdouts_map:
+            return self.flag_holdouts_map[flag_id]
+
         # Prioritize global holdouts first
         excluded = self.excluded_holdouts.get(flag_id, [])
 
         if excluded:
-            # Filter out excluded holdouts from global holdouts
-            active_holdouts = [
-                holdout for holdout in self.global_holdouts
-                if holdout not in excluded
-            ]
+            active_holdouts = [holdout for holdout in self.global_holdouts if holdout not in excluded]
         else:
             active_holdouts = self.global_holdouts.copy()
 
         # Append included holdouts
         included = self.included_holdouts.get(flag_id, [])
         active_holdouts.extend(included)
 
-        # Cache the result using the input parameter as the cache key
-        self.flag_holdouts_map[flag_key_or_id] = active_holdouts
+        # Cache the result
+        self.flag_holdouts_map[flag_id] = active_holdouts
 
-        return self.flag_holdouts_map[flag_key_or_id]
+        return self.flag_holdouts_map[flag_id]
 
     def get_holdout(self, holdout_id: str) -> Optional[HoldoutDict]:
         """ Helper method to get holdout from holdout ID.