feat: odp datafile parsing and audience evaluation (#393)

* swap user attributes for user_context

* add integrations

* add qualified segments

Author: andrewleap-optimizely

optimizely/decision_service.py

@@ -268,7 +268,6 @@ def get_variation(
           And an array of log messages representing decision making.
         """
         user_id = user_context.user_id
-        attributes = user_context.get_user_attributes()
 
         if options:
             ignore_user_profile = OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE in options
@@ -323,7 +322,7 @@ def get_variation(
             project_config, audience_conditions,
             enums.ExperimentAudienceEvaluationLogs,
             experiment.key,
-            attributes, self.logger)
+            user_context, self.logger)
         decide_reasons += reasons_received
         if not user_meets_audience_conditions:
             message = f'User "{user_id}" does not meet conditions to be in experiment "{experiment.key}".'
@@ -332,7 +331,7 @@ def get_variation(
             return None, decide_reasons
 
         # Determine bucketing ID to be used
-        bucketing_id, bucketing_id_reasons = self._get_bucketing_id(user_id, attributes)
+        bucketing_id, bucketing_id_reasons = self._get_bucketing_id(user_id, user_context.get_user_attributes())
         decide_reasons += bucketing_id_reasons
         variation, bucket_reasons = self.bucketer.bucket(project_config, experiment, user_id, bucketing_id)
         decide_reasons += bucket_reasons
@@ -354,7 +353,7 @@ def get_variation(
         return None, decide_reasons
 
     def get_variation_for_rollout(
-        self, project_config: ProjectConfig, feature: entities.FeatureFlag, user: OptimizelyUserContext
+        self, project_config: ProjectConfig, feature: entities.FeatureFlag, user_context: OptimizelyUserContext
     ) -> tuple[Decision, list[str]]:
         """ Determine which experiment/variation the user is in for a given rollout.
             Returns the variation of the first experiment the user qualifies for.
@@ -371,8 +370,8 @@ def get_variation_for_rollout(
           array of log messages representing decision making.
         """
         decide_reasons: list[str] = []
-        user_id = user.user_id
-        attributes = user.get_user_attributes()
+        user_id = user_context.user_id
+        attributes = user_context.get_user_attributes()
 
         if not feature or not feature.rolloutId:
             return Decision(None, None, enums.DecisionSources.ROLLOUT), decide_reasons
@@ -401,7 +400,7 @@ def get_variation_for_rollout(
             rule = rollout_rules[index]
             optimizely_decision_context = OptimizelyUserContext.OptimizelyDecisionContext(feature.key, rule.key)
             forced_decision_variation, reasons_received = self.validated_forced_decision(
-                project_config, optimizely_decision_context, user)
+                project_config, optimizely_decision_context, user_context)
             decide_reasons += reasons_received
 
             if forced_decision_variation:
@@ -422,7 +421,7 @@ def get_variation_for_rollout(
 
             audience_decision_response, reasons_received_audience = audience_helper.does_user_meet_audience_conditions(
                 project_config, audience_conditions, enums.RolloutRuleAudienceEvaluationLogs,
-                logging_key, attributes, self.logger)
+                logging_key, user_context, self.logger)
 
             decide_reasons += reasons_received_audience
 

optimizely/entities.py

@@ -52,6 +52,16 @@ def __init__(
         self.conditionStructure = conditionStructure
         self.conditionList = conditionList
 
+    def get_segments(self) -> list[str]:
+        """ Extract all audience segments used in the this audience's conditions.
+
+        Returns:
+            List of segment names.
+        """
+        if not self.conditionList:
+            return []
+        return list({c[1] for c in self.conditionList if c[3] == 'qualified'})
+
 
 class Event(BaseEntity):
     def __init__(self, id: str, key: str, experimentIds: list[str], **kwargs: Any):
@@ -175,3 +185,10 @@ def __init__(
 
     def __str__(self) -> str:
         return self.key
+
+
+class Integration(BaseEntity):
+    def __init__(self, key: str, host: Optional[str] = None, publicKey: Optional[str] = None):
+        self.key = key
+        self.host = host
+        self.publicKey = publicKey

optimizely/helpers/audience.py

@@ -31,7 +31,7 @@ def does_user_meet_audience_conditions(
     audience_conditions: Optional[Sequence[str | list[str]]],
     audience_logs: Type[ExperimentAudienceEvaluationLogs | RolloutRuleAudienceEvaluationLogs],
     logging_key: str,
-    attributes: Optional[optimizely_user_context.UserAttributes],
+    user_context: optimizely_user_context.OptimizelyUserContext,
     logger: Logger
 ) -> tuple[bool, list[str]]:
     """ Determine for given experiment if user satisfies the audiences for the experiment.
@@ -62,15 +62,12 @@ def does_user_meet_audience_conditions(
 
         return True, decide_reasons
 
-    if attributes is None:
-        attributes = optimizely_user_context.UserAttributes({})
-
     def evaluate_custom_attr(audience_id: str, index: int) -> Optional[bool]:
         audience = config.get_audience(audience_id)
         if not audience or audience.conditionList is None:
             return None
         custom_attr_condition_evaluator = condition_helper.CustomAttributeConditionEvaluator(
-            audience.conditionList, attributes, logger
+            audience.conditionList, user_context, logger
         )
 
         return custom_attr_condition_evaluator.evaluate(index)

optimizely/helpers/condition.py

@@ -55,21 +55,23 @@ class ConditionMatchTypes:
     SEMVER_LE: Final = 'semver_le'
     SEMVER_LT: Final = 'semver_lt'
     SUBSTRING: Final = 'substring'
+    QUALIFIED: Final = 'qualified'
 
 
 class CustomAttributeConditionEvaluator:
     """ Class encapsulating methods to be used in audience leaf condition evaluation. """
 
-    CUSTOM_ATTRIBUTE_CONDITION_TYPE: Final = 'custom_attribute'
+    CONDITION_TYPES: Final = ('custom_attribute', 'third_party_dimension')
 
     def __init__(
         self,
         condition_data: list[str | list[str]],
-        attributes: Optional[optimizely_user_context.UserAttributes],
+        user_context: optimizely_user_context.OptimizelyUserContext,
         logger: Logger
     ):
         self.condition_data = condition_data
-        self.attributes = attributes or optimizely_user_context.UserAttributes({})
+        self.user_context = user_context
+        self.attributes = user_context.get_user_attributes()
         self.logger = logger
 
     def _get_condition_json(self, index: int) -> str:
@@ -613,7 +615,27 @@ def semver_greater_than_or_equal_evaluator(self, index: int) -> Optional[bool]:
 
         return result >= 0
 
-    EVALUATORS_BY_MATCH_TYPE = {
+    def qualified_evaluator(self, index: int) -> Optional[bool]:
+        """ Check if the user is qualifed for the given segment.
+
+        Args:
+        index: Index of the condition to be evaluated.
+
+        Returns:
+        Boolean:
+            - True if the user is qualified.
+            - False if the user is not qualified.
+        None: if the condition value isn't a string.
+        """
+        condition_value = self.condition_data[index][1]
+
+        if not isinstance(condition_value, str):
+            self.logger.warning(audience_logs.UNKNOWN_CONDITION_VALUE.format(self._get_condition_json(index),))
+            return None
+
+        return self.user_context.is_qualified_for(condition_value)
+
+    EVALUATORS_BY_MATCH_TYPE: dict[str, Callable[[CustomAttributeConditionEvaluator, int], Optional[bool]]] = {
         ConditionMatchTypes.EXACT: exact_evaluator,
         ConditionMatchTypes.EXISTS: exists_evaluator,
         ConditionMatchTypes.GREATER_THAN: greater_than_evaluator,
@@ -625,7 +647,8 @@ def semver_greater_than_or_equal_evaluator(self, index: int) -> Optional[bool]:
         ConditionMatchTypes.SEMVER_GT: semver_greater_than_evaluator,
         ConditionMatchTypes.SEMVER_LE: semver_less_than_or_equal_evaluator,
         ConditionMatchTypes.SEMVER_LT: semver_less_than_evaluator,
-        ConditionMatchTypes.SUBSTRING: substring_evaluator
+        ConditionMatchTypes.SUBSTRING: substring_evaluator,
+        ConditionMatchTypes.QUALIFIED: qualified_evaluator
     }
 
     def split_version(self, version: str) -> Optional[list[str]]:
@@ -696,7 +719,7 @@ def evaluate(self, index: int) -> Optional[bool]:
       None: if the user attributes and condition can't be evaluated.
     """
 
-        if self.condition_data[index][2] != self.CUSTOM_ATTRIBUTE_CONDITION_TYPE:
+        if self.condition_data[index][2] not in self.CONDITION_TYPES:
             self.logger.warning(audience_logs.UNKNOWN_CONDITION_TYPE.format(self._get_condition_json(index)))
             return None
 
@@ -708,7 +731,7 @@ def evaluate(self, index: int) -> Optional[bool]:
             self.logger.warning(audience_logs.UNKNOWN_MATCH_TYPE.format(self._get_condition_json(index)))
             return None
 
-        if condition_match != ConditionMatchTypes.EXISTS:
+        if condition_match not in (ConditionMatchTypes.EXISTS, ConditionMatchTypes.QUALIFIED):
             attribute_key = self.condition_data[index][0]
             if attribute_key not in self.attributes:
                 self.logger.debug(

optimizely/helpers/constants.py

@@ -149,6 +149,14 @@
         },
         "version": {"type": "string"},
         "revision": {"type": "string"},
+        "integrations": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {"key": {"type": "string"}, "host": {"type": "string"}, "publicKey": {"type": "string"}},
+                "required": ["key"],
+            }
+        }
     },
     "required": [
         "projectId",

optimizely/helpers/types.py

@@ -30,43 +30,43 @@ class BaseEntity(TypedDict):
 
 
 class BaseDict(BaseEntity):
-    '''Base type for parsed datafile json, before instantiation of class objects.'''
+    """Base type for parsed datafile json, before instantiation of class objects."""
     id: str
     key: str
 
 
 class EventDict(BaseDict):
-    '''Event dict from parsed datafile json.'''
+    """Event dict from parsed datafile json."""
     experimentIds: list[str]
 
 
 class AttributeDict(BaseDict):
-    '''Attribute dict from parsed datafile json.'''
+    """Attribute dict from parsed datafile json."""
     pass
 
 
 class TrafficAllocation(BaseEntity):
-    '''Traffic Allocation dict from parsed datafile json.'''
+    """Traffic Allocation dict from parsed datafile json."""
     endOfRange: int
     entityId: str
 
 
 class VariableDict(BaseDict):
-    '''Variable dict from parsed datafile json.'''
+    """Variable dict from parsed datafile json."""
     value: str
     type: str
     defaultValue: str
     subType: str
 
 
 class VariationDict(BaseDict):
-    '''Variation dict from parsed datafile json.'''
+    """Variation dict from parsed datafile json."""
     variables: list[VariableDict]
     featureEnabled: Optional[bool]
 
 
 class ExperimentDict(BaseDict):
-    '''Experiment dict from parsed datafile json.'''
+    """Experiment dict from parsed datafile json."""
     status: str
     forcedVariations: dict[str, str]
     variations: list[VariationDict]
@@ -77,28 +77,35 @@ class ExperimentDict(BaseDict):
 
 
 class RolloutDict(BaseEntity):
-    '''Rollout dict from parsed datafile json.'''
+    """Rollout dict from parsed datafile json."""
     id: str
     experiments: list[ExperimentDict]
 
 
 class FeatureFlagDict(BaseDict):
-    '''Feature flag dict from parsed datafile json.'''
+    """Feature flag dict from parsed datafile json."""
     rolloutId: str
     variables: list[VariableDict]
     experimentIds: list[str]
 
 
 class GroupDict(BaseEntity):
-    '''Group dict from parsed datafile json.'''
+    """Group dict from parsed datafile json."""
     id: str
     policy: str
     experiments: list[ExperimentDict]
     trafficAllocation: list[TrafficAllocation]
 
 
 class AudienceDict(BaseEntity):
-    '''Audience dict from parsed datafile json.'''
+    """Audience dict from parsed datafile json."""
     id: str
     name: str
     conditions: list[Any] | str
+
+
+class IntegrationDict(BaseEntity):
+    """Integration dict from parsed datafile json."""
+    key: str
+    host: str
+    publicKey: str

optimizely/optimizely_user_context.py

@@ -54,6 +54,7 @@ def __init__(
         self.client = optimizely_client
         self.logger = logger
         self.user_id = user_id
+        self._qualified_segments: list[str] = []
 
         if not isinstance(user_attributes, dict):
             user_attributes = UserAttributes({})
@@ -94,7 +95,11 @@ def _clone(self) -> Optional[OptimizelyUserContext]:
 
         with self.lock:
             if self.forced_decisions_map:
+                # makes sure forced_decisions_map is duplicated without any references
                 user_context.forced_decisions_map = copy.deepcopy(self.forced_decisions_map)
+            if self._qualified_segments:
+                # no need to use deepcopy here as qualified_segments does not contain anything other than strings
+                user_context._qualified_segments = self._qualified_segments.copy()
 
         return user_context
 
@@ -248,3 +253,39 @@ def find_forced_decision(self, decision_context: OptimizelyDecisionContext) -> O
 
             # must allow None to be returned for the Flags only case
             return self.forced_decisions_map.get(decision_context)
+
+    def is_qualified_for(self, segment: str) -> bool:
+        """
+        Checks is the provided segment is in the qualified_segments list.
+
+        Args:
+            segment: a segment name.
+
+        Returns:
+            Returns: true if the segment is in the qualified segments list.
+        """
+        with self.lock:
+            return segment in self._qualified_segments
+
+    def get_qualified_segments(self) -> list[str]:
+        """
+        Gets the qualified segments.
+
+        Returns:
+            A list of qualified segment names.
+        """
+        with self.lock:
+            return self._qualified_segments.copy()
+
+    def set_qualified_segments(self, segments: list[str]) -> None:
+        """
+        Replaces any qualified segments with the provided list of segments.
+
+        Args:
+            segments: a list of segment names.
+
+        Returns:
+            None.
+        """
+        with self.lock:
+            self._qualified_segments = segments.copy()