Changing to use objects (#21)

Author: aliabbasrizvi

optimizely/bucketer.py

@@ -77,76 +77,60 @@ def _find_bucket(self, user_id, parent_id, traffic_allocations):
 
     return None
 
-  def bucket(self, experiment_key, user_id):
-    """ For a given experiment key and bucketing ID determines ID of variation to be shown to visitor.
+  def bucket(self, experiment, user_id):
+    """ For a given experiment and bucketing ID determines ID of variation to be shown to user.
 
     Args:
-      experiment_key: Key representing experiment for which visitor is to be bucketed.
+      experiment: Object representing the experiment for which user is to be bucketed.
       user_id: ID for user.
 
     Returns:
       Variation ID for variation in which the visitor with ID user_id will be put in. None if no variation.
     """
 
+    if not experiment:
+      return None
+
     # Check if user is white-listed for a variation
-    forced_variations = self.config.get_experiment_forced_variations(experiment_key)
+    forced_variations = experiment.forcedVariations
     if forced_variations and user_id in forced_variations:
       variation_key = forced_variations.get(user_id)
-      variation_id = self.config.get_variation_id(experiment_key, variation_key)
+      variation_id = self.config.get_variation_id(experiment.key, variation_key)
       if variation_id:
         self.config.logger.log(enums.LogLevels.INFO,
                                'User "%s" is forced in variation "%s".' % (user_id, variation_key))
       return variation_id
 
-    # Determine experiment ID
-    experiment_id = self.config.get_experiment_id(experiment_key)
-    if not experiment_id:
-      return None
-
     # Determine if experiment is in a mutually exclusive group
-    group_policy = self.config.get_experiment_group_policy(experiment_key)
-    if group_policy in GROUP_POLICIES:
-      group_id = self.config.get_experiment_group_id(experiment_key)
-
-      if not group_id:
-        return None
-
-      group_traffic_allocations = self.config.get_traffic_allocation(self.config.group_id_map, group_id)
+    if experiment.groupPolicy in GROUP_POLICIES:
+      group_traffic_allocations = self.config.get_traffic_allocation(self.config.group_id_map, experiment.groupId)
 
       if not group_traffic_allocations:
-        self.config.logger.log(enums.LogLevels.ERROR, 'Group ID "%s" is not in datafile.' % group_id)
+        self.config.logger.log(enums.LogLevels.ERROR, 'Group ID "%s" is not in datafile.' % experiment.groupId)
         self.config.error_handler.handle_error(
           exceptions.InvalidExperimentException(enums.Errors.INVALID_GROUP_ID_ERROR)
         )
         return None
 
-      user_experiment_id = self._find_bucket(user_id, group_id, group_traffic_allocations)
+      user_experiment_id = self._find_bucket(user_id, experiment.groupId, group_traffic_allocations)
       if not user_experiment_id:
         self.config.logger.log(enums.LogLevels.INFO, 'User "%s" is in no experiment.' % user_id)
         return None
 
-      if user_experiment_id != experiment_id:
+      if user_experiment_id != experiment.id:
         self.config.logger.log(enums.LogLevels.INFO, 'User "%s" is not in experiment "%s" of group %s.' %
-                               (user_id, experiment_key, group_id))
+                               (user_id, experiment.key, experiment.groupId))
         return None
 
       self.config.logger.log(enums.LogLevels.INFO, 'User "%s" is in experiment %s of group %s.' %
-                             (user_id, experiment_key, group_id))
+                             (user_id, experiment.key, experiment.groupId))
 
     # Bucket user if not in white-list and in group (if any)
-    experiment_traffic_allocations = self.config.get_traffic_allocation(self.config.experiment_key_map, experiment_key)
-    if not experiment_traffic_allocations:
-      self.config.logger.log(enums.LogLevels.ERROR, 'Experiment key "%s" is not in datafile.' % experiment_key)
-      self.config.error_handler.handle_error(
-        exceptions.InvalidExperimentException(enums.Errors.INVALID_EXPERIMENT_KEY_ERROR)
-      )
-      return None
-
-    variation_id = self._find_bucket(user_id, experiment_id, experiment_traffic_allocations)
+    variation_id = self._find_bucket(user_id, experiment.id, experiment.trafficAllocation)
     if variation_id:
-      variation_key = self.config.get_variation_key_from_id(experiment_key, variation_id)
+      variation_key = self.config.get_variation_key_from_id(experiment.key, variation_id)
       self.config.logger.log(enums.LogLevels.INFO, 'User "%s" is in variation "%s" of experiment %s.' %
-                             (user_id, variation_key, experiment_key))
+                             (user_id, variation_key, experiment.key))
       return variation_id
 
     self.config.logger.log(enums.LogLevels.INFO, 'User "%s" is in no variation.' % user_id)

optimizely/entities.py

@@ -0,0 +1,36 @@
+class BaseEntity(object):
+
+  def __eq__(self, other):
+    return self.__dict__ == other.__dict__
+
+
+class Attribute(BaseEntity):
+
+  def __init__(self, id, key, segmentId=None):
+    self.id = id
+    self.key = key
+    self.segmentId = segmentId
+
+
+class Event(BaseEntity):
+
+  def __init__(self, id, key, experimentIds):
+    self.id = id
+    self.key = key
+    self.experimentIds = experimentIds
+
+
+class Experiment(BaseEntity):
+
+  def __init__(self, id, key, status, audienceIds, variations, forcedVariations,
+               trafficAllocation, layerId=None, groupId=None, groupPolicy=None):
+    self.id = id
+    self.key = key
+    self.status = status
+    self.audienceIds = audienceIds
+    self.variations = variations
+    self.forcedVariations = forcedVariations
+    self.trafficAllocation = trafficAllocation
+    self.layerId = layerId
+    self.groupId = groupId
+    self.groupPolicy = groupPolicy

optimizely/event_builder.py

@@ -132,28 +132,27 @@ def _add_time(self):
 
     self.params[self.EventParams.TIME] = int(time.time())
 
-  def _add_impression_goal(self, experiment_key):
+  def _add_impression_goal(self, experiment):
     """ Add impression goal information to the event.
 
     Args:
-      experiment_key: Experiment which is being activated.
+      experiment: Object representing experiment being activated.
     """
 
     # For tracking impressions, goal ID is set equal to experiment ID of experiment being activated
-    self.params[self.EventParams.GOAL_ID] = self.config.get_experiment_id(experiment_key)
+    self.params[self.EventParams.GOAL_ID] = experiment.id
     self.params[self.EventParams.GOAL_NAME] = 'visitor-event'
 
-  def _add_experiment(self, experiment_key, variation_id):
+  def _add_experiment(self, experiment, variation_id):
     """ Add experiment to variation mapping to the impression event.
 
     Args:
-      experiment_key: Experiment which is being activated.
+      experiment: Object representing experiment being activated.
       variation_id: ID for variation which would be presented to user.
     """
 
-    experiment_id = self.config.get_experiment_id(experiment_key)
     self.params[self.EXPERIMENT_PARAM_FORMAT.format(experiment_prefix=self.EventParams.EXPERIMENT_PREFIX,
-                                                    experiment_id=experiment_id)] = variation_id
+                                                    experiment_id=experiment.id)] = variation_id
 
   def _add_experiment_variation_params(self, user_id, valid_experiments):
     """ Maps experiment and corresponding variation as parameters to be used in the event tracking call.
@@ -164,10 +163,10 @@ def _add_experiment_variation_params(self, user_id, valid_experiments):
     """
 
     for experiment in valid_experiments:
-      variation_id = self.bucketer.bucket(experiment[1], user_id)
+      variation_id = self.bucketer.bucket(experiment, user_id)
       if variation_id:
         self.params[self.EXPERIMENT_PARAM_FORMAT.format(experiment_prefix=self.EventParams.EXPERIMENT_PREFIX,
-                                                        experiment_id=experiment[0])] = variation_id
+                                                        experiment_id=experiment.id)] = variation_id
 
   def _add_conversion_goal(self, event_key, event_value):
     """ Add conversion goal information to the event.
@@ -178,6 +177,10 @@ def _add_conversion_goal(self, event_key, event_value):
     """
 
     event = self.config.get_event(event_key)
+
+    if not event:
+      return
+
     event_ids = event.id
 
     if event_value:
@@ -188,11 +191,11 @@ def _add_conversion_goal(self, event_key, event_value):
     self.params[self.EventParams.GOAL_ID] = event_ids
     self.params[self.EventParams.GOAL_NAME] = event_key
 
-  def create_impression_event(self, experiment_key, variation_id, user_id, attributes):
+  def create_impression_event(self, experiment, variation_id, user_id, attributes):
     """ Create impression Event to be sent to the logging endpoint.
 
     Args:
-      experiment_key: Experiment for which impression needs to be recorded.
+      experiment: Object representing experiment for which impression needs to be recorded.
       variation_id: ID for variation which would be presented to user.
       user_id: ID for user.
       attributes: Dict representing user attributes and values which need to be recorded.
@@ -203,8 +206,8 @@ def create_impression_event(self, experiment_key, variation_id, user_id, attribu
 
     self.params = {}
     self._add_common_params(user_id, attributes)
-    self._add_impression_goal(experiment_key)
-    self._add_experiment(experiment_key, variation_id)
+    self._add_impression_goal(experiment)
+    self._add_experiment(experiment, variation_id)
     return Event(self.OFFLINE_API_PATH.format(project_id=self.params[self.EventParams.PROJECT_ID]),
                  self.params)
 
@@ -296,18 +299,18 @@ def _add_time(self):
 
     self.params[self.EventParams.TIME] = int(round(time.time() * 1000))
 
-  def _add_required_params_for_impression(self, experiment_key, variation_id):
+  def _add_required_params_for_impression(self, experiment, variation_id):
     """ Add parameters that are required for the impression event to register.
 
     Args:
-      experiment_key: Experiment for which impression needs to be recorded.
+      experiment: Experiment for which impression needs to be recorded.
       variation_id: ID for variation which would be presented to user.
     """
 
     self.params[self.EventParams.IS_GLOBAL_HOLDBACK] = False
-    self.params[self.EventParams.LAYER_ID] = self.config.get_layer_id_for_experiment(experiment_key)
+    self.params[self.EventParams.LAYER_ID] = experiment.layerId
     self.params[self.EventParams.DECISION] = {
-      self.EventParams.EXPERIMENT_ID: self.config.get_experiment_id(experiment_key),
+      self.EventParams.EXPERIMENT_ID: experiment.id,
       self.EventParams.VARIATION_ID: variation_id,
       self.EventParams.IS_LAYER_HOLDBACK: False
     }
@@ -334,13 +337,13 @@ def _add_required_params_for_conversion(self, event_key, user_id, event_value, v
 
     self.params[self.EventParams.LAYER_STATES] = []
     for experiment in valid_experiments:
-      variation_id = self.bucketer.bucket(experiment[1], user_id)
+      variation_id = self.bucketer.bucket(experiment, user_id)
       if variation_id:
         self.params[self.EventParams.LAYER_STATES].append({
-          self.EventParams.LAYER_ID: self.config.get_layer_id_for_experiment(experiment[1]),
+          self.EventParams.LAYER_ID: experiment.layerId,
           self.EventParams.ACTION_TRIGGERED: True,
           self.EventParams.DECISION: {
-            self.EventParams.EXPERIMENT_ID: experiment[0],
+            self.EventParams.EXPERIMENT_ID: experiment.id,
             self.EventParams.VARIATION_ID: variation_id,
             self.EventParams.IS_LAYER_HOLDBACK: False
           }
@@ -349,11 +352,11 @@ def _add_required_params_for_conversion(self, event_key, user_id, event_value, v
     self.params[self.EventParams.EVENT_ID] = self.config.get_event(event_key).id
     self.params[self.EventParams.EVENT_NAME] = event_key
 
-  def create_impression_event(self, experiment_key, variation_id, user_id, attributes):
+  def create_impression_event(self, experiment, variation_id, user_id, attributes):
     """ Create impression Event to be sent to the logging endpoint.
 
     Args:
-      experiment_key: Experiment for which impression needs to be recorded.
+      experiment: Experiment for which impression needs to be recorded.
       variation_id: ID for variation which would be presented to user.
       user_id: ID for user.
       attributes: Dict representing user attributes and values which need to be recorded.
@@ -364,7 +367,7 @@ def create_impression_event(self, experiment_key, variation_id, user_id, attribu
 
     self.params = {}
     self._add_common_params(user_id, attributes)
-    self._add_required_params_for_impression(experiment_key, variation_id)
+    self._add_required_params_for_impression(experiment, variation_id)
     return Event(self.IMPRESSION_ENDPOINT,
                  self.params,
                  http_verb=self.HTTP_VERB,

optimizely/helpers/audience.py

@@ -15,30 +15,28 @@ def is_match(audience, attributes):
   return condition_evaluator.evaluate(audience.get('conditionStructure'))
 
 
-def is_user_in_experiment(config, experiment_key, attributes):
+def is_user_in_experiment(config, experiment, attributes):
   """ Determine for given experiment if user satisfies the audiences for the experiment.
 
   Args:
     config: project_config.ProjectConfig object representing the project.
-    experiment_key: Key representing experiment for which user is to be bucketed.
+    experiment: Object representing the experiment.
     attributes: Dict representing user attributes which will be used in determining if the audience conditions are met.
 
   Returns:
     Boolean representing if user satisfies audience conditions for any of the audiences or not.
   """
 
-  audience_ids = config.get_audience_ids_for_experiment(experiment_key)
-
   # Return True in case there are no audiences
-  if not audience_ids:
+  if not experiment.audienceIds:
     return True
 
   # Return False if there are audiences, but no attributes
   if not attributes:
     return False
 
   # Return True if conditions for any one audience are met
-  for audience_id in audience_ids:
+  for audience_id in experiment.audienceIds:
     audience = config.get_audience_object_from_id(audience_id)
 
     if is_match(audience, attributes):

optimizely/helpers/experiment.py

@@ -1,15 +1,14 @@
 ALLOWED_EXPERIMENT_STATUS = ['Running']
 
 
-def is_experiment_running(config, experiment_key):
+def is_experiment_running(experiment):
   """ Determine for given experiment if experiment is running.
 
   Args:
-    config: project_config.ProjectConfig object representing the project.
-    experiment_key: Key representing experiment for which user is to be bucketed.
+    experiment: Object representing the experiment.
 
   Returns:
     Boolean representing if experiment is running or not.
   """
 
-  return config.get_experiment_status(experiment_key) in ALLOWED_EXPERIMENT_STATUS
+  return experiment.status in ALLOWED_EXPERIMENT_STATUS