Add Audiences to OptimizelyConfig and expose in OptimizelyExperiment

optimizely/decision_service.py

@@ -342,7 +342,7 @@ def get_variation_for_rollout(self, project_config, rollout, user_id, attributes
         if rollout and len(rollout.experiments) > 0:
             for idx in range(len(rollout.experiments) - 1):
                 logging_key = str(idx + 1)
-                rollout_rule = project_config.get_experiment_from_key(rollout.experiments[idx].get('key'))
+                rollout_rule = project_config.get_experiment_from_id(rollout.experiments[idx].get('id'))
 
                 # Check if user meets audience conditions for targeting rule
                 audience_conditions = rollout_rule.get_audience_conditions_or_ids()
@@ -387,7 +387,7 @@ def get_variation_for_rollout(self, project_config, rollout, user_id, attributes
                     break
 
             # Evaluate last rule i.e. "Everyone Else" rule
-            everyone_else_rule = project_config.get_experiment_from_key(rollout.experiments[-1].get('key'))
+            everyone_else_rule = project_config.get_experiment_from_id(rollout.experiments[-1].get('id'))
             audience_conditions = everyone_else_rule.get_audience_conditions_or_ids()
             audience_eval, audience_reasons = audience_helper.does_user_meet_audience_conditions(
                 project_config,

optimizely/helpers/condition.py

@@ -26,6 +26,7 @@ class ConditionOperatorTypes(object):
     AND = 'and'
     OR = 'or'
     NOT = 'not'
+    operators = [AND, OR, NOT]
 
 
 class ConditionMatchTypes(object):

optimizely/optimizely_config.py

@@ -12,13 +12,15 @@
 # limitations under the License.
 
 import copy
+from .helpers.condition import ConditionOperatorTypes
 
 from .project_config import ProjectConfig
 
 
 class OptimizelyConfig(object):
     def __init__(self, revision, experiments_map, features_map, datafile=None,
-                 sdk_key=None, environment_key=None, attributes=None, events=None):
+                 sdk_key=None, environment_key=None, attributes=None, events=None,
+                 audiences=None, delivery_rules=None):
         self.revision = revision
         self.experiments_map = experiments_map
         self.features_map = features_map
@@ -27,6 +29,8 @@ def __init__(self, revision, experiments_map, features_map, datafile=None,
         self.environment_key = environment_key
         self.attributes = attributes or []
         self.events = events or []
+        self.audiences = audiences or []
+        self.delivery_rules = delivery_rules or []
 
     def get_datafile(self):
         """ Get the datafile associated with OptimizelyConfig.
@@ -68,12 +72,29 @@ def get_events(self):
         """
         return self.events
 
+    def get_audiences(self):
+        """ Get the audiences associated with OptimizelyConfig
+
+        returns:
+            A list of audiences.
+        """
+        return self.audiences
+
+    def get_delivery_rules(self):
+        """ Get the delivery rules list associated with OptimizelyConfig
+
+        Returns:
+            List of OptimizelyExperiments as DeliveryRules from Rollouts
+        """
+        return self.delivery_rules
+
 
 class OptimizelyExperiment(object):
     def __init__(self, id, key, variations_map):
         self.id = id
         self.key = key
         self.variations_map = variations_map
+        self.audiences = ""
 
 
 class OptimizelyFeature(object):
@@ -113,6 +134,13 @@ def __init__(self, id, key, experiment_ids):
         self.experiment_ids = experiment_ids
 
 
+class OptimizelyAudience(object):
+    def __init__(self, id, name, conditions):
+        self.id = id
+        self.name = name
+        self.conditions = conditions
+
+
 class OptimizelyConfigService(object):
     """ Class encapsulating methods to be used in creating instance of OptimizelyConfig. """
 
@@ -136,9 +164,130 @@ def __init__(self, project_config):
         self.environment_key = project_config.environment_key
         self.attributes = project_config.attributes
         self.events = project_config.events
+        self.rollouts = project_config.rollouts
 
         self._create_lookup_maps()
 
+        '''
+            Merging typed_audiences with audiences from project_config.
+            The typed_audiences has higher presidence.
+        '''
+
+        typed_audiences = project_config.typed_audiences[:]
+        optly_typed_audiences = []
+        for typed_audience in typed_audiences:
+            optly_audience = OptimizelyAudience(
+                typed_audience.get('id'),
+                typed_audience.get('name'),
+                typed_audience.get('conditions')
+            )
+            optly_typed_audiences.append(optly_audience)
+
+        for old_audience in project_config.audiences:
+            # check if old_audience.id exists in new_audiences.id from typed_audiences
+            if len([new_audience for new_audience in project_config.typed_audiences
+                    if new_audience.get('id') == old_audience.get('id')]) == 0:
+                if old_audience.get('id') == "$opt_dummy_audience":
+                    continue
+                else:
+                    # Convert audiences lists to OptimizelyAudience array
+                    optly_audience = OptimizelyAudience(
+                        old_audience.get('id'),
+                        old_audience.get('name'),
+                        old_audience.get('conditions')
+                    )
+                    optly_typed_audiences.append(optly_audience)
+
+        self.audiences = optly_typed_audiences
+
+    def replace_ids_with_names(self, conditions, audiences_map):
+        '''
+            Gets conditions and audiences_map [id:name]
+
+            Returns:
+                a string of conditions with id's swapped with names
+                or None if no conditions found.
+
+        '''
+        if conditions is not None:
+            return self.stringify_conditions(conditions, audiences_map)
+        else:
+            return None
+
+    def lookup_name_from_id(self, audience_id, audiences_map):
+        '''
+            Gets and audience ID and audiences map
+
+            Returns:
+                The name corresponding to the ID
+                or None if not found.
+        '''
+        name = ""
+        try:
+            name = audiences_map[audience_id]
+        except KeyError:
+            name = audience_id
+
+        return name
+
+    def stringify_conditions(self, conditions, audiences_map):
+        '''
+            Gets a list of conditions from an entities.Experiment
+            and an audiences_map [id:name]
+
+            Returns:
+                A string of conditions and names for the provided
+                list of conditions.
+        '''
+        ARGS = ConditionOperatorTypes.operators
+        condition = ""
+        conditions_str = ""
+        length = len(conditions)
+
+        if length == 0:
+            return
+        if length == 1:
+            # Lookup ID and replace with name
+            audience_name = self.lookup_name_from_id(conditions[0], audiences_map)
+
+            return '"' + audience_name + '"'
+
+        if length == 2:
+            if conditions[0] in ARGS:
+                condition = conditions[0]
+                audience_name = self.lookup_name_from_id(conditions[1], audiences_map)
+                return condition.upper() + ' "' + audience_name + '"'
+            else:
+                condition = 'OR'
+                name1 = self.lookup_name_from_id(conditions[0], audiences_map)
+                name2 = self.lookup_name_from_id(conditions[1], audiences_map)
+                return ('"' + name1 + '" ' + condition.upper() + ' "' + name2 + '"')
+
+        if length > 2:
+            for i in range(length):
+                if conditions[i] in ARGS:
+                    condition = conditions[i].upper()
+                else:
+                    if condition == "":
+                        condition = 'OR'
+                    if type(conditions[i]) == list:
+                        # If the next item is a list, recursively call function on list
+                        if i + 1 < length:
+                            conditions_str += '(' + self.stringify_conditions(conditions[i], audiences_map) + ') '
+                            conditions_str += condition + ' '
+                        else:
+                            conditions_str += '(' + self.stringify_conditions(conditions[i], audiences_map) + ')'
+                    else:
+                        # Handle IDs here - Lookup name based on ID
+                        audience_name = self.lookup_name_from_id(conditions[i], audiences_map)
+                        if audience_name is not None:
+                            if i + 1 < length:
+                                conditions_str += '"' + audience_name + '" ' + condition + ' '
+                            else:
+                                conditions_str += '"' + audience_name + '"'
+
+        return conditions_str + ""
+
     def get_config(self):
         """ Gets instance of OptimizelyConfig
 
@@ -159,8 +308,11 @@ def get_config(self):
             self._datafile,
             self.sdk_key,
             self.environment_key,
-            self.attributes,
-            self.events)
+            self._get_attributes_list(self.attributes),
+            self._get_events_list(self.events),
+            self.audiences,
+            self._get_delivery_rules(self.rollouts)
+        )
 
     def _create_lookup_maps(self):
         """ Creates lookup maps to avoid redundant iteration of config objects.  """
@@ -248,7 +400,8 @@ def _get_all_experiments(self):
         return experiments
 
     def _get_experiments_maps(self):
-        """ Gets maps for all the experiments in the project config.
+        """ Gets maps for all the experiments in the project config and
+        updates the experiment with updated experiment audiences string.
 
         Returns:
             dict, dict -- experiment key/id to OptimizelyExperiment maps.
@@ -257,12 +410,21 @@ def _get_experiments_maps(self):
         experiments_key_map = {}
         # Id map comes in handy to figure out feature experiment.
         experiments_id_map = {}
+        # Audiences map to use for updating experiments with new audience conditions string
+        audiences_map = {}
+
+        # Build map from OptimizelyAudience array
+        for optly_audience in self.audiences:
+            audiences_map[optly_audience.id] = optly_audience.name
 
         all_experiments = self._get_all_experiments()
         for exp in all_experiments:
             optly_exp = OptimizelyExperiment(
                 exp['id'], exp['key'], self._get_variations_map(exp)
             )
+            # Updating each OptimizelyExperiment
+            audiences = self.replace_ids_with_names(exp.get('audienceConditions', []), audiences_map)
+            optly_exp.audiences = audiences
 
             experiments_key_map[exp['key']] = optly_exp
             experiments_id_map[exp['id']] = optly_exp
@@ -295,3 +457,65 @@ def _get_features_map(self, experiments_id_map):
             features_map[feature['key']] = optly_feature
 
         return features_map
+
+    def _get_delivery_rules(self, rollouts):
+        """ Gets an array of rollouts for the project config
+
+        returns:
+            an array of OptimizelyExperiments as delivery rules.
+        """
+        # Return list for delivery rules
+        delivery_rules = []
+        # Audiences map to use for updating experiments with new audience conditions string
+        audiences_map = {}
+
+        # Build map from OptimizelyAudience array
+        for optly_audience in self.audiences:
+            audiences_map[optly_audience.id] = optly_audience.name
+
+        for rollout in rollouts:
+            experiments = rollout.get('experiments_map')
+            if experiments:
+                for experiment in experiments:
+                    optly_exp = OptimizelyExperiment(
+                        experiment['id'], experiment['key'], self._get_variations_map(experiment)
+                    )
+                    self.update_experiment(optly_exp, experiment.get('audienceConditions', []), audiences_map)
+                    delivery_rules.append(optly_exp)
+
+        return delivery_rules
+
+    def _get_attributes_list(self, attributes):
+        """ Gets attributes list for the project config
+
+        Returns:
+            List - OptimizelyAttributes
+        """
+        attributes_list = []
+
+        for attribute in attributes:
+            optly_attribute = OptimizelyAttribute(
+                attribute['id'],
+                attribute['key']
+            )
+            attributes_list.append(optly_attribute)
+
+        return attributes_list
+
+    def _get_events_list(self, events):
+        """ Gets events list for the project_config
+
+        Returns:
+            List - OptimizelyEvents
+        """
+        events_list = []
+
+        for event in events:
+            optly_event = OptimizelyEvent(
+                event['id'],
+                event['key'],
+                event['experimentIds']
+            )
+            events_list.append(optly_event)
+
+        return events_list