optimizely-sdk 5.0.1__tar.gz → 5.1.0__tar.gz

{optimizely-sdk-5.0.1 → optimizely_sdk-5.1.0}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Optimizely Python SDK Changelog
 
+## 5.1.0
+November 27th, 2024
+
+Added support for batch processing in DecideAll and DecideForKeys, enabling more efficient handling of multiple decisions in the User Profile Service.([#440](https://github.com/optimizely/python-sdk/pull/440))
+
 ## 5.0.1
 June 26th, 2024
 

{optimizely-sdk-5.0.1/optimizely_sdk.egg-info → optimizely_sdk-5.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: optimizely-sdk
-Version: 5.0.1
+Version: 5.1.0
 Summary: Python SDK for Optimizely Feature Experimentation, Optimizely Full Stack (legacy), and Optimizely Rollouts.
 Home-page: https://github.com/optimizely/python-sdk
 Author: Optimizely
@@ -23,16 +23,16 @@ Requires-Dist: pyrsistent>=0.16.0
 Requires-Dist: requests>=2.21
 Requires-Dist: idna>=2.10
 Provides-Extra: test
+Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: idna>=2.10; extra == "test"
 Requires-Dist: jsonschema>=3.2.0; extra == "test"
-Requires-Dist: python-coveralls; extra == "test"
-Requires-Dist: flake8>=4.0.1; extra == "test"
-Requires-Dist: pytest>=6.2.0; extra == "test"
-Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: requests>=2.21; extra == "test"
 Requires-Dist: funcsigs>=0.4; extra == "test"
-Requires-Dist: pyrsistent>=0.16.0; extra == "test"
+Requires-Dist: pytest>=6.2.0; extra == "test"
+Requires-Dist: python-coveralls; extra == "test"
 Requires-Dist: coverage; extra == "test"
+Requires-Dist: flake8>=4.0.1; extra == "test"
+Requires-Dist: pyrsistent>=0.16.0; extra == "test"
 
 Optimizely Feature Experimentation is A/B testing and feature management for product development teams. Experiment in any application. Make every feature on your roadmap an opportunity to learn. Learn more at https://www.optimizely.com/products/experiment/feature-experimentation/ or see our documentation at https://docs.developers.optimizely.com/experimentation/v4.0.0-full-stack/docs/welcome. # Optimizely Python SDK
 
@@ -292,6 +292,11 @@ idna (BSD 3-Clause License https://github.com/kjd/idna/blob/master/LICENSE.md)
 - Swift - https://github.com/optimizely/swift-sdk
 # Optimizely Python SDK Changelog
 
+## 5.1.0
+November 27th, 2024
+
+Added support for batch processing in DecideAll and DecideForKeys, enabling more efficient handling of multiple decisions in the User Profile Service.([#440](https://github.com/optimizely/python-sdk/pull/440))
+
 ## 5.0.1
 June 26th, 2024
 

{optimizely-sdk-5.0.1 → optimizely_sdk-5.1.0}/optimizely/decision_service.py

@@ -22,7 +22,7 @@ from .helpers import enums
 from .helpers import experiment as experiment_helper
 from .helpers import validator
 from .optimizely_user_context import OptimizelyUserContext, UserAttributes
-from .user_profile import UserProfile, UserProfileService
+from .user_profile import UserProfile, UserProfileService, UserProfileTracker
 
 if TYPE_CHECKING:
     # prevent circular dependenacy by skipping import at runtime
@@ -35,7 +35,7 @@ class Decision(NamedTuple):
     None if no experiment/variation was selected."""
     experiment: Optional[entities.Experiment]
     variation: Optional[entities.Variation]
-    source: str
+    source: Optional[str]
 
 
 class DecisionService:
@@ -247,6 +247,8 @@ class DecisionService:
         project_config: ProjectConfig,
         experiment: entities.Experiment,
         user_context: OptimizelyUserContext,
+        user_profile_tracker: Optional[UserProfileTracker],
+        reasons: list[str] = [],
         options: Optional[Sequence[str]] = None
     ) -> tuple[Optional[entities.Variation], list[str]]:
         """ Top-level function to help determine variation user should be put in.
@@ -260,7 +262,9 @@ class DecisionService:
         Args:
           project_config: Instance of ProjectConfig.
           experiment: Experiment for which user variation needs to be determined.
-          user_context: contains user id and attributes
+          user_context: contains user id and attributes.
+          user_profile_tracker: tracker for reading and updating user profile of the user.
+          reasons: Decision reasons.
           options: Decide options.
 
         Returns:
@@ -275,6 +279,8 @@ class DecisionService:
             ignore_user_profile = False
 
         decide_reasons = []
+        if reasons is not None:
+            decide_reasons += reasons
         # Check if experiment is running
         if not experiment_helper.is_experiment_running(experiment):
             message = f'Experiment "{experiment.key}" is not running.'
@@ -296,23 +302,14 @@ class DecisionService:
             return variation, decide_reasons
 
         # Check to see if user has a decision available for the given experiment
-        user_profile = UserProfile(user_id)
-        if not ignore_user_profile and self.user_profile_service:
-            try:
-                retrieved_profile = self.user_profile_service.lookup(user_id)
-            except:
-                self.logger.exception(f'Unable to retrieve user profile for user "{user_id}" as lookup failed.')
-                retrieved_profile = None
-
-            if retrieved_profile and validator.is_user_profile_valid(retrieved_profile):
-                user_profile = UserProfile(**retrieved_profile)
-                variation = self.get_stored_variation(project_config, experiment, user_profile)
-                if variation:
-                    message = f'Returning previously activated variation ID "{variation}" of experiment ' \
-                              f'"{experiment}" for user "{user_id}" from user profile.'
-                    self.logger.info(message)
-                    decide_reasons.append(message)
-                    return variation, decide_reasons
+        if user_profile_tracker is not None and not ignore_user_profile:
+            variation = self.get_stored_variation(project_config, experiment, user_profile_tracker.get_user_profile())
+            if variation:
+                message = f'Returning previously activated variation ID "{variation}" of experiment ' \
+                          f'"{experiment}" for user "{user_id}" from user profile.'
+                self.logger.info(message)
+                decide_reasons.append(message)
+                return variation, decide_reasons
             else:
                 self.logger.warning('User profile has invalid format.')
 
@@ -340,10 +337,9 @@ class DecisionService:
             self.logger.info(message)
             decide_reasons.append(message)
             # Store this new decision and return the variation for the user
-            if not ignore_user_profile and self.user_profile_service:
+            if user_profile_tracker is not None and not ignore_user_profile:
                 try:
-                    user_profile.save_variation_for_experiment(experiment.id, variation.id)
-                    self.user_profile_service.save(user_profile.__dict__)
+                    user_profile_tracker.update_user_profile(experiment, variation)
                 except:
                     self.logger.exception(f'Unable to save user profile for user "{user_id}".')
             return variation, decide_reasons
@@ -479,44 +475,7 @@ class DecisionService:
         Returns:
           Decision namedtuple consisting of experiment and variation for the user.
     """
-        decide_reasons = []
-
-        # Check if the feature flag is under an experiment and the the user is bucketed into one of these experiments
-        if feature.experimentIds:
-            # Evaluate each experiment ID and return the first bucketed experiment variation
-            for experiment_id in feature.experimentIds:
-                experiment = project_config.get_experiment_from_id(experiment_id)
-                decision_variation = None
-
-                if experiment:
-                    optimizely_decision_context = OptimizelyUserContext.OptimizelyDecisionContext(feature.key,
-                                                                                                  experiment.key)
-
-                    forced_decision_variation, reasons_received = self.validated_forced_decision(
-                        project_config, optimizely_decision_context, user_context)
-                    decide_reasons += reasons_received
-
-                    if forced_decision_variation:
-                        decision_variation = forced_decision_variation
-                    else:
-                        decision_variation, variation_reasons = self.get_variation(project_config,
-                                                                                   experiment, user_context, options)
-                        decide_reasons += variation_reasons
-
-                    if decision_variation:
-                        message = f'User "{user_context.user_id}" bucketed into a ' \
-                                  f'experiment "{experiment.key}" of feature "{feature.key}".'
-                        self.logger.debug(message)
-                        return Decision(experiment, decision_variation,
-                                        enums.DecisionSources.FEATURE_TEST), decide_reasons
-
-        message = f'User "{user_context.user_id}" is not bucketed into any of the ' \
-                  f'experiments on the feature "{feature.key}".'
-        self.logger.debug(message)
-        variation, rollout_variation_reasons = self.get_variation_for_rollout(project_config, feature, user_context)
-        if rollout_variation_reasons:
-            decide_reasons += rollout_variation_reasons
-        return variation, decide_reasons
+        return self.get_variations_for_feature_list(project_config, [feature], user_context, options)[0]
 
     def validated_forced_decision(
         self,
@@ -580,3 +539,91 @@ class DecisionService:
                 user_context.logger.info(user_has_forced_decision_but_invalid)
 
         return None, reasons
+
+    def get_variations_for_feature_list(
+        self,
+        project_config: ProjectConfig,
+        features: list[entities.FeatureFlag],
+        user_context: OptimizelyUserContext,
+        options: Optional[Sequence[str]] = None
+    ) -> list[tuple[Decision, list[str]]]:
+        """
+        Returns the list of experiment/variation the user is bucketed in for the given list of features.
+        Args:
+                project_config: Instance of ProjectConfig.
+                features: List of features for which we are determining if it is enabled or not for the given user.
+                user_context: user context for user.
+                options: Decide options.
+
+        Returns:
+            List of Decision namedtuple consisting of experiment and variation for the user.
+        """
+        decide_reasons: list[str] = []
+
+        if options:
+            ignore_ups = OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE in options
+        else:
+            ignore_ups = False
+
+        user_profile_tracker: Optional[UserProfileTracker] = None
+        if self.user_profile_service is not None and not ignore_ups:
+            user_profile_tracker = UserProfileTracker(user_context.user_id, self.user_profile_service, self.logger)
+            user_profile_tracker.load_user_profile(decide_reasons, None)
+
+        decisions = []
+
+        for feature in features:
+            feature_reasons = decide_reasons.copy()
+            experiment_decision_found = False  # Track if an experiment decision was made for the feature
+
+            # Check if the feature flag is under an experiment
+            if feature.experimentIds:
+                for experiment_id in feature.experimentIds:
+                    experiment = project_config.get_experiment_from_id(experiment_id)
+                    decision_variation = None
+
+                    if experiment:
+                        optimizely_decision_context = OptimizelyUserContext.OptimizelyDecisionContext(
+                            feature.key, experiment.key)
+                        forced_decision_variation, reasons_received = self.validated_forced_decision(
+                            project_config, optimizely_decision_context, user_context)
+                        feature_reasons.extend(reasons_received)
+
+                        if forced_decision_variation:
+                            decision_variation = forced_decision_variation
+                        else:
+                            decision_variation, variation_reasons = self.get_variation(
+                                project_config, experiment, user_context, user_profile_tracker, feature_reasons, options
+                            )
+                            feature_reasons.extend(variation_reasons)
+
+                        if decision_variation:
+                            self.logger.debug(
+                                f'User "{user_context.user_id}" '
+                                f'bucketed into experiment "{experiment.key}" of feature "{feature.key}".'
+                            )
+                            decision = Decision(experiment, decision_variation, enums.DecisionSources.FEATURE_TEST)
+                            decisions.append((decision, feature_reasons))
+                            experiment_decision_found = True  # Mark that a decision was found
+                            break  # Stop after the first successful experiment decision
+
+            # Only process rollout if no experiment decision was found
+            if not experiment_decision_found:
+                rollout_decision, rollout_reasons = self.get_variation_for_rollout(project_config,
+                                                                                   feature,
+                                                                                   user_context)
+                if rollout_reasons:
+                    feature_reasons.extend(rollout_reasons)
+                if rollout_decision:
+                    self.logger.debug(f'User "{user_context.user_id}" '
+                                      f'bucketed into rollout for feature "{feature.key}".')
+                else:
+                    self.logger.debug(f'User "{user_context.user_id}" '
+                                      f'not bucketed into any rollout for feature "{feature.key}".')
+
+                decisions.append((rollout_decision, feature_reasons))
+
+        if self.user_profile_service is not None and user_profile_tracker is not None and ignore_ups is False:
+            user_profile_tracker.save_user_profile()
+
+        return decisions

{optimizely-sdk-5.0.1 → optimizely_sdk-5.1.0}/optimizely/optimizely.py

@@ -21,6 +21,7 @@ from . import event_builder
 from . import exceptions
 from . import logger as _logging
 from . import project_config
+from . import user_profile
 from .config_manager import AuthDatafilePollingConfigManager
 from .config_manager import BaseConfigManager
 from .config_manager import PollingConfigManager
@@ -42,6 +43,7 @@ from .odp.lru_cache import LRUCache
 from .odp.odp_manager import OdpManager
 from .optimizely_config import OptimizelyConfig, OptimizelyConfigService
 from .optimizely_user_context import OptimizelyUserContext, UserAttributes
+from .project_config import ProjectConfig
 
 if TYPE_CHECKING:
     # prevent circular dependency by skipping import at runtime
@@ -168,6 +170,7 @@ class Optimizely:
 
         self.event_builder = event_builder.EventBuilder()
         self.decision_service = decision_service.DecisionService(self.logger, user_profile_service)
+        self.user_profile_service = user_profile_service
 
     def _validate_instantiation_options(self) -> None:
         """ Helper method to validate all instantiation parameters.
@@ -629,8 +632,13 @@ class Optimizely:
             return None
 
         user_context = OptimizelyUserContext(self, self.logger, user_id, attributes, False)
-
-        variation, _ = self.decision_service.get_variation(project_config, experiment, user_context)
+        user_profile_tracker = user_profile.UserProfileTracker(user_id, self.user_profile_service, self.logger)
+        user_profile_tracker.load_user_profile()
+        variation, _ = self.decision_service.get_variation(project_config,
+                                                           experiment,
+                                                           user_context,
+                                                           user_profile_tracker)
+        user_profile_tracker.save_user_profile()
         if variation:
             variation_key = variation.key
 
@@ -701,7 +709,7 @@ class Optimizely:
         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, decision.experiment.key if
-                decision.experiment else '', decision.source, feature_enabled, user_id, attributes
+                decision.experiment else '', str(decision.source), feature_enabled, user_id, attributes
             )
 
         # Send event if Decision came from an experiment.
@@ -712,7 +720,7 @@ class Optimizely:
             }
             self._send_impression_event(
                 project_config, decision.experiment, decision.variation, feature.key, decision.experiment.key,
-                decision.source, feature_enabled, user_id, attributes
+                str(decision.source), feature_enabled, user_id, attributes
             )
 
         if feature_enabled:
@@ -1118,73 +1126,70 @@ class Optimizely:
             self.logger.debug('Provided decide options is not an array. Using default decide options.')
             decide_options = self.default_decide_options
 
-        # Create Optimizely Decision Result.
+        if OptimizelyDecideOption.ENABLED_FLAGS_ONLY in decide_options:
+            decide_options.remove(OptimizelyDecideOption.ENABLED_FLAGS_ONLY)
+
+        decision = self._decide_for_keys(
+            user_context,
+            [key],
+            decide_options,
+            True
+        )[key]
+
+        return decision
+
+    def _create_optimizely_decision(
+            self,
+            user_context: OptimizelyUserContext,
+            flag_key: str,
+            flag_decision: Decision,
+            decision_reasons: Optional[list[str]],
+            decide_options: list[str],
+            project_config: ProjectConfig
+    ) -> OptimizelyDecision:
         user_id = user_context.user_id
-        attributes = user_context.get_user_attributes()
-        variation_key = None
-        variation = None
         feature_enabled = False
-        rule_key = None
-        flag_key = key
+        if flag_decision.variation is not None:
+            if flag_decision.variation.featureEnabled:
+                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 = flag_decision.experiment.key if flag_decision.experiment else None
         all_variables = {}
-        experiment = None
-        decision_source = DecisionSources.ROLLOUT
-        source_info: dict[str, Any] = {}
+        decision_source = flag_decision.source
         decision_event_dispatched = False
 
-        # Check forced decisions first
-        optimizely_decision_context = OptimizelyUserContext.OptimizelyDecisionContext(flag_key=key, rule_key=rule_key)
-        forced_decision_response = self.decision_service.validated_forced_decision(config,
-                                                                                   optimizely_decision_context,
-                                                                                   user_context)
-        variation, decision_reasons = forced_decision_response
-        reasons += decision_reasons
-
-        if variation:
-            decision = Decision(None, variation, enums.DecisionSources.FEATURE_TEST)
-        else:
-            # Regular decision
-            decision, decision_reasons = self.decision_service.get_variation_for_feature(config,
-                                                                                         feature_flag,
-                                                                                         user_context, decide_options)
-
-            reasons += decision_reasons
-
-        # Fill in experiment and variation if returned (rollouts can have featureEnabled variables as well.)
-        if decision.experiment is not None:
-            experiment = decision.experiment
-            source_info["experiment"] = experiment
-            rule_key = experiment.key if experiment else None
-        if decision.variation is not None:
-            variation = decision.variation
-            variation_key = variation.key
-            feature_enabled = variation.featureEnabled
-            decision_source = decision.source
-            source_info["variation"] = variation
+        feature_flag = project_config.feature_key_map.get(flag_key)
 
         # Send impression event if Decision came from a feature
         # test and decide options doesn't include disableDecisionEvent
         if OptimizelyDecideOption.DISABLE_DECISION_EVENT not in decide_options:
-            if decision_source == DecisionSources.FEATURE_TEST or config.send_flag_decisions:
-                self._send_impression_event(config, experiment, variation, flag_key, rule_key or '',
-                                            decision_source, feature_enabled,
+            if decision_source == DecisionSources.FEATURE_TEST or project_config.send_flag_decisions:
+                self._send_impression_event(project_config,
+                                            flag_decision.experiment,
+                                            flag_decision.variation,
+                                            flag_key, rule_key or '',
+                                            str(decision_source), feature_enabled,
                                             user_id, attributes)
 
                 decision_event_dispatched = True
 
         # Generate all variables map if decide options doesn't include excludeVariables
-        if OptimizelyDecideOption.EXCLUDE_VARIABLES not in decide_options:
+        if OptimizelyDecideOption.EXCLUDE_VARIABLES not in decide_options and feature_flag:
             for variable_key, variable in feature_flag.variables.items():
                 variable_value = variable.defaultValue
                 if feature_enabled:
-                    variable_value = config.get_variable_value_for_variation(variable, decision.variation)
+                    variable_value = project_config.get_variable_value_for_variation(variable, flag_decision.variation)
                     self.logger.debug(
                         f'Got variable value "{variable_value}" for '
                         f'variable "{variable_key}" of feature flag "{flag_key}".'
                     )
 
                 try:
-                    actual_value = config.get_typecast_value(variable_value, variable.type)
+                    actual_value = project_config.get_typecast_value(variable_value, variable.type)
                 except:
                     self.logger.error('Unable to cast value. Returning None.')
                     actual_value = None
@@ -1192,7 +1197,11 @@ class Optimizely:
                 all_variables[variable_key] = actual_value
 
         should_include_reasons = OptimizelyDecideOption.INCLUDE_REASONS in decide_options
-
+        variation_key = (
+            flag_decision.variation.key
+            if flag_decision is not None and flag_decision.variation is not None
+            else None
+        )
         # Send notification
         self.notification_center.send_notifications(
             enums.NotificationTypes.DECISION,
@@ -1205,7 +1214,7 @@ class Optimizely:
                 'variables': all_variables,
                 'variation_key': variation_key,
                 'rule_key': rule_key,
-                'reasons': reasons if should_include_reasons else [],
+                'reasons': decision_reasons if should_include_reasons else [],
                 'decision_event_dispatched': decision_event_dispatched
 
             },
@@ -1213,7 +1222,7 @@ class Optimizely:
 
         return OptimizelyDecision(variation_key=variation_key, enabled=feature_enabled, variables=all_variables,
                                   rule_key=rule_key, flag_key=flag_key,
-                                  user_context=user_context, reasons=reasons if should_include_reasons else []
+                                  user_context=user_context, reasons=decision_reasons if should_include_reasons else []
                                   )
 
     def _decide_all(
@@ -1253,7 +1262,8 @@ class Optimizely:
         self,
         user_context: Optional[OptimizelyUserContext],
         keys: list[str],
-        decide_options: Optional[list[str]] = None
+        decide_options: Optional[list[str]] = None,
+        ignore_default_options: bool = False
     ) -> dict[str, OptimizelyDecision]:
         """
         Args:
@@ -1277,19 +1287,74 @@ class Optimizely:
         merged_decide_options: list[str] = []
         if isinstance(decide_options, list):
             merged_decide_options = decide_options[:]
-            merged_decide_options += self.default_decide_options
+            if not ignore_default_options:
+                merged_decide_options += self.default_decide_options
         else:
             self.logger.debug('Provided decide options is not an array. Using default decide options.')
             merged_decide_options = self.default_decide_options
 
-        enabled_flags_only = OptimizelyDecideOption.ENABLED_FLAGS_ONLY in merged_decide_options
+        decisions: dict[str, OptimizelyDecision] = {}
+        valid_keys = []
+        decision_reasons_dict = {}
+
+        project_config = self.config_manager.get_config()
+        flags_without_forced_decision: list[entities.FeatureFlag] = []
+        flag_decisions: dict[str, Decision] = {}
 
-        decisions = {}
+        if project_config is None:
+            return decisions
         for key in keys:
-            decision = self._decide(user_context, key, decide_options)
-            if enabled_flags_only and not decision.enabled:
+            feature_flag = project_config.feature_key_map.get(key)
+            if feature_flag is None:
+                decisions[key] = OptimizelyDecision(None, False, None, None, key, user_context, [])
                 continue
-            decisions[key] = decision
+            valid_keys.append(key)
+            decision_reasons: list[str] = []
+            decision_reasons_dict[key] = decision_reasons
+
+            optimizely_decision_context = OptimizelyUserContext.OptimizelyDecisionContext(flag_key=key, rule_key=None)
+            forced_decision_response = self.decision_service.validated_forced_decision(project_config,
+                                                                                       optimizely_decision_context,
+                                                                                       user_context)
+            variation, decision_reasons = forced_decision_response
+            decision_reasons_dict[key] += decision_reasons
+
+            if variation:
+                decision = Decision(None, variation, enums.DecisionSources.FEATURE_TEST)
+                flag_decisions[key] = decision
+            else:
+                flags_without_forced_decision.append(feature_flag)
+
+        decision_list = self.decision_service.get_variations_for_feature_list(
+            project_config,
+            flags_without_forced_decision,
+            user_context,
+            merged_decide_options
+        )
+
+        for i in range(0, len(flags_without_forced_decision)):
+            decision = decision_list[i][0]
+            reasons = decision_list[i][1]
+            flag_key = flags_without_forced_decision[i].key
+            flag_decisions[flag_key] = decision
+            decision_reasons_dict[flag_key] += reasons
+
+        for key in valid_keys:
+            flag_decision = flag_decisions[key]
+            decision_reasons = decision_reasons_dict[key]
+            optimizely_decision = self._create_optimizely_decision(
+                user_context,
+                key,
+                flag_decision,
+                decision_reasons,
+                merged_decide_options,
+                project_config
+            )
+            enabled_flags_only_missing = OptimizelyDecideOption.ENABLED_FLAGS_ONLY not in merged_decide_options
+            is_enabled = optimizely_decision.enabled
+            if enabled_flags_only_missing or is_enabled:
+                decisions[key] = optimizely_decision
+
         return decisions
 
     def _setup_odp(self, sdk_key: Optional[str]) -> None:

optimizely_sdk-5.1.0/optimizely/user_profile.py

@@ -0,0 +1,157 @@
+# Copyright 2017, 2022, Optimizely
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+from typing import Any, Optional
+from sys import version_info
+from . import logger as _logging
+
+if version_info < (3, 8):
+    from typing_extensions import Final
+else:
+    from typing import Final, TYPE_CHECKING  # type: ignore
+
+    if TYPE_CHECKING:
+        # prevent circular dependenacy by skipping import at runtime
+        from .entities import Experiment, Variation
+        from optimizely.error_handler import BaseErrorHandler
+
+
+class UserProfile:
+    """ Class encapsulating information representing a user's profile.
+
+   user_id: User's identifier.
+   experiment_bucket_map: Dict mapping experiment ID to dict consisting of the
+                          variation ID identifying the variation for the user.
+   """
+
+    USER_ID_KEY: Final = 'user_id'
+    EXPERIMENT_BUCKET_MAP_KEY: Final = 'experiment_bucket_map'
+    VARIATION_ID_KEY: Final = 'variation_id'
+
+    def __init__(
+        self,
+        user_id: str,
+        experiment_bucket_map: Optional[dict[str, dict[str, Optional[str]]]] = None,
+        **kwargs: Any
+    ):
+        self.user_id = user_id
+        self.experiment_bucket_map = experiment_bucket_map or {}
+
+    def __eq__(self, other: object) -> bool:
+        return self.__dict__ == other.__dict__
+
+    def get_variation_for_experiment(self, experiment_id: str) -> Optional[str]:
+        """ Helper method to retrieve variation ID for given experiment.
+
+    Args:
+      experiment_id: ID for experiment for which variation needs to be looked up for.
+
+    Returns:
+      Variation ID corresponding to the experiment. None if no decision available.
+    """
+        return self.experiment_bucket_map.get(experiment_id, {self.VARIATION_ID_KEY: None}).get(self.VARIATION_ID_KEY)
+
+    def save_variation_for_experiment(self, experiment_id: str, variation_id: str) -> None:
+        """ Helper method to save new experiment/variation as part of the user's profile.
+
+    Args:
+      experiment_id: ID for experiment for which the decision is to be stored.
+      variation_id: ID for variation that the user saw.
+    """
+        self.experiment_bucket_map.update({experiment_id: {self.VARIATION_ID_KEY: variation_id}})
+
+
+class UserProfileService:
+    """ Class encapsulating user profile service functionality.
+  Override with your own implementation for storing and retrieving the user profile. """
+
+    def lookup(self, user_id: str) -> dict[str, Any]:
+        """ Fetch the user profile dict corresponding to the user ID.
+
+    Args:
+      user_id: ID for user whose profile needs to be retrieved.
+
+    Returns:
+      Dict representing the user's profile.
+    """
+        return UserProfile(user_id).__dict__
+
+    def save(self, user_profile: dict[str, Any]) -> None:
+        """ Save the user profile dict sent to this method.
+
+    Args:
+      user_profile: Dict representing the user's profile.
+    """
+        pass
+
+
+class UserProfileTracker:
+    def __init__(self,
+                 user_id: str,
+                 user_profile_service: Optional[UserProfileService],
+                 logger: Optional[_logging.Logger] = None):
+        self.user_id = user_id
+        self.user_profile_service = user_profile_service
+        self.logger = _logging.adapt_logger(logger or _logging.NoOpLogger())
+        self.profile_updated = False
+        self.user_profile = UserProfile(user_id, {})
+
+    def get_user_profile(self) -> UserProfile:
+        return self.user_profile
+
+    def load_user_profile(self, reasons: Optional[list[str]] = [],
+                          error_handler: Optional[BaseErrorHandler] = None) -> None:
+        if reasons is None:
+            reasons = []
+        try:
+            user_profile = self.user_profile_service.lookup(self.user_id) if self.user_profile_service else None
+            if user_profile is None:
+                message = "Unable to get a user profile from the UserProfileService."
+                reasons.append(message)
+            else:
+                if 'user_id' in user_profile and 'experiment_bucket_map' in user_profile:
+                    self.user_profile = UserProfile(
+                        user_profile['user_id'],
+                        user_profile['experiment_bucket_map']
+                    )
+                    self.logger.info("User profile loaded successfully.")
+                else:
+                    missing_keys = [key for key in ['user_id', 'experiment_bucket_map'] if key not in user_profile]
+                    message = f"User profile is missing keys: {', '.join(missing_keys)}"
+                    reasons.append(message)
+        except Exception as exception:
+            message = str(exception)
+            reasons.append(message)
+            self.logger.exception(f'Unable to retrieve user profile for user "{self.user_id}" as lookup failed.')
+            if error_handler:
+                error_handler.handle_error(exception)
+
+    def update_user_profile(self, experiment: Experiment, variation: Variation) -> None:
+        variation_id = variation.id
+        experiment_id = experiment.id
+        self.user_profile.save_variation_for_experiment(experiment_id, variation_id)
+        self.profile_updated = True
+
+    def save_user_profile(self, error_handler: Optional[BaseErrorHandler] = None) -> None:
+        if not self.profile_updated:
+            return
+        try:
+            if self.user_profile_service:
+                self.user_profile_service.save(self.user_profile.__dict__)
+                self.logger.info(f'Saved user profile of user "{self.user_profile.user_id}".')
+        except Exception as exception:
+            self.logger.warning(f'Failed to save user profile of user "{self.user_profile.user_id}" '
+                                f'for exception:{exception}".')
+            if error_handler:
+                error_handler.handle_error(exception)

{optimizely-sdk-5.0.1 → optimizely_sdk-5.1.0}/optimizely/version.py

@@ -11,5 +11,5 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-version_info = (5, 0, 1)
+version_info = (5, 1, 0)
 __version__ = '.'.join(str(v) for v in version_info)

{optimizely-sdk-5.0.1 → optimizely_sdk-5.1.0/optimizely_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: optimizely-sdk
-Version: 5.0.1
+Version: 5.1.0
 Summary: Python SDK for Optimizely Feature Experimentation, Optimizely Full Stack (legacy), and Optimizely Rollouts.
 Home-page: https://github.com/optimizely/python-sdk
 Author: Optimizely
@@ -23,16 +23,16 @@ Requires-Dist: pyrsistent>=0.16.0
 Requires-Dist: requests>=2.21
 Requires-Dist: idna>=2.10
 Provides-Extra: test
+Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: idna>=2.10; extra == "test"
 Requires-Dist: jsonschema>=3.2.0; extra == "test"
-Requires-Dist: python-coveralls; extra == "test"
-Requires-Dist: flake8>=4.0.1; extra == "test"
-Requires-Dist: pytest>=6.2.0; extra == "test"
-Requires-Dist: pytest-cov; extra == "test"
 Requires-Dist: requests>=2.21; extra == "test"
 Requires-Dist: funcsigs>=0.4; extra == "test"
-Requires-Dist: pyrsistent>=0.16.0; extra == "test"
+Requires-Dist: pytest>=6.2.0; extra == "test"
+Requires-Dist: python-coveralls; extra == "test"
 Requires-Dist: coverage; extra == "test"
+Requires-Dist: flake8>=4.0.1; extra == "test"
+Requires-Dist: pyrsistent>=0.16.0; extra == "test"
 
 Optimizely Feature Experimentation is A/B testing and feature management for product development teams. Experiment in any application. Make every feature on your roadmap an opportunity to learn. Learn more at https://www.optimizely.com/products/experiment/feature-experimentation/ or see our documentation at https://docs.developers.optimizely.com/experimentation/v4.0.0-full-stack/docs/welcome. # Optimizely Python SDK
 
@@ -292,6 +292,11 @@ idna (BSD 3-Clause License https://github.com/kjd/idna/blob/master/LICENSE.md)
 - Swift - https://github.com/optimizely/swift-sdk
 # Optimizely Python SDK Changelog
 
+## 5.1.0
+November 27th, 2024
+
+Added support for batch processing in DecideAll and DecideForKeys, enabling more efficient handling of multiple decisions in the User Profile Service.([#440](https://github.com/optimizely/python-sdk/pull/440))
+
 ## 5.0.1
 June 26th, 2024
 

optimizely-sdk-5.0.1/optimizely/user_profile.py

@@ -1,92 +0,0 @@
-# Copyright 2017, 2022, Optimizely
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-from typing import Any, Optional
-from sys import version_info
-
-if version_info < (3, 8):
-    from typing_extensions import Final
-else:
-    from typing import Final  # type: ignore
-
-
-class UserProfile:
-    """ Class encapsulating information representing a user's profile.
-
-   user_id: User's identifier.
-   experiment_bucket_map: Dict mapping experiment ID to dict consisting of the
-                          variation ID identifying the variation for the user.
-   """
-
-    USER_ID_KEY: Final = 'user_id'
-    EXPERIMENT_BUCKET_MAP_KEY: Final = 'experiment_bucket_map'
-    VARIATION_ID_KEY: Final = 'variation_id'
-
-    def __init__(
-        self,
-        user_id: str,
-        experiment_bucket_map: Optional[dict[str, dict[str, Optional[str]]]] = None,
-        **kwargs: Any
-    ):
-        self.user_id = user_id
-        self.experiment_bucket_map = experiment_bucket_map or {}
-
-    def __eq__(self, other: object) -> bool:
-        return self.__dict__ == other.__dict__
-
-    def get_variation_for_experiment(self, experiment_id: str) -> Optional[str]:
-        """ Helper method to retrieve variation ID for given experiment.
-
-    Args:
-      experiment_id: ID for experiment for which variation needs to be looked up for.
-
-    Returns:
-      Variation ID corresponding to the experiment. None if no decision available.
-    """
-
-        return self.experiment_bucket_map.get(experiment_id, {self.VARIATION_ID_KEY: None}).get(self.VARIATION_ID_KEY)
-
-    def save_variation_for_experiment(self, experiment_id: str, variation_id: str) -> None:
-        """ Helper method to save new experiment/variation as part of the user's profile.
-
-    Args:
-      experiment_id: ID for experiment for which the decision is to be stored.
-      variation_id: ID for variation that the user saw.
-    """
-
-        self.experiment_bucket_map.update({experiment_id: {self.VARIATION_ID_KEY: variation_id}})
-
-
-class UserProfileService:
-    """ Class encapsulating user profile service functionality.
-  Override with your own implementation for storing and retrieving the user profile. """
-
-    def lookup(self, user_id: str) -> dict[str, Any]:
-        """ Fetch the user profile dict corresponding to the user ID.
-
-    Args:
-      user_id: ID for user whose profile needs to be retrieved.
-
-    Returns:
-      Dict representing the user's profile.
-    """
-        return UserProfile(user_id).__dict__
-
-    def save(self, user_profile: dict[str, Any]) -> None:
-        """ Save the user profile dict sent to this method.
-
-    Args:
-      user_profile: Dict representing the user's profile.
-    """
-        pass

{optimizely-sdk-5.0.1 → optimizely_sdk-5.1.0}/optimizely_sdk.egg-info/requires.txt

@@ -4,13 +4,13 @@ requests>=2.21
 idna>=2.10
 
 [test]
+pytest-cov
 idna>=2.10
 jsonschema>=3.2.0
-python-coveralls
-flake8>=4.0.1
-pytest>=6.2.0
-pytest-cov
 requests>=2.21
 funcsigs>=0.4
-pyrsistent>=0.16.0
+pytest>=6.2.0
+python-coveralls
 coverage
+flake8>=4.0.1
+pyrsistent>=0.16.0