Add feature flag parsing (#57)

Author: mikeproeng37

optimizely/entities.py

@@ -58,35 +58,57 @@ def __init__(self, id, key, status, audienceIds, variations, forcedVariations,
     self.groupPolicy = groupPolicy
 
 
-class FeatureFlag(BaseEntity):
+class Feature(BaseEntity):
+
+  def __init__(self, id, key, experimentIds, layerId, variables, groupId=None, **kwargs):
+    self.id = id
+    self.key = key
+    self.experimentIds = experimentIds
+    self.layerId = layerId
+    self.variables = variables
+    self.groupId = groupId
+
+class Group(BaseEntity):
+
+  def __init__(self, id, policy, experiments, trafficAllocation, **kwargs):
+    self.id = id
+    self.policy = policy
+    self.experiments = experiments
+    self.trafficAllocation = trafficAllocation
+
+
+class Layer(BaseEntity):
+
+  def __init__(self, id, policy, experiments, **kwargs):
+    self.id = id
+    self.policy = policy
+    self.experiments = experiments
+
+
+class Variable(BaseEntity):
 
   class Type(object):
     BOOLEAN = 'boolean'
     DOUBLE = 'double'
     INTEGER = 'integer'
     STRING = 'string'
 
-
   def __init__(self, id, key, type, defaultValue, **kwargs):
     self.id = id
     self.key = key
     self.type = type
     self.defaultValue = defaultValue
 
 
-class Group(BaseEntity):
-
-  def __init__(self, id, policy, experiments, trafficAllocation, **kwargs):
-    self.id = id
-    self.policy = policy
-    self.experiments = experiments
-    self.trafficAllocation = trafficAllocation
+class Variation(BaseEntity):
 
+  class VariableUsage(BaseEntity):
 
-class Variation(BaseEntity):
+    def __init__(self, id, value, **kwards):
+      self.id = id
+      self.value = value
 
-  def __init__(self, id, key, variables=None, featureFlagMap=None, **kwargs):
+  def __init__(self, id, key, variables=None, **kwargs):
     self.id = id
     self.key = key
     self.variables = variables or []
-    self.featureFlagMap = featureFlagMap or {}

optimizely/project_config.py

@@ -53,15 +53,20 @@ def __init__(self, datafile, logger, error_handler):
     self.events = config.get('events', [])
     self.attributes = config.get('attributes', [])
     self.audiences = config.get('audiences', [])
-    self.feature_flags = config.get('variables', [])
+    self.features = config.get('features', [])
+    self.layers = config.get('layers', [])
 
     # Utility maps for quick lookup
     self.group_id_map = self._generate_key_map(self.groups, 'id', entities.Group)
     self.experiment_key_map = self._generate_key_map(self.experiments, 'key', entities.Experiment)
     self.event_key_map = self._generate_key_map(self.events, 'key', entities.Event)
     self.attribute_key_map = self._generate_key_map(self.attributes, 'key', entities.Attribute)
     self.audience_id_map = self._generate_key_map(self.audiences, 'id', entities.Audience)
-    self.feature_flag_id_map = self._generate_key_map(self.feature_flags, 'id', entities.FeatureFlag)
+    self.layer_id_map = self._generate_key_map(self.layers, 'id', entities.Layer)
+    for layer in self.layer_id_map.values():
+      for experiment in layer.experiments:
+        self.experiment_key_map[experiment['key']] = entities.Experiment(**experiment)
+
     self.audience_id_map = self._deserialize_audience(self.audience_id_map)
     for group in self.group_id_map.values():
       experiments_in_group_key_map = self._generate_key_map(group.experiments, 'key', entities.Experiment)
@@ -75,16 +80,29 @@ def __init__(self, datafile, logger, error_handler):
     self.experiment_id_map = {}
     self.variation_key_map = {}
     self.variation_id_map = {}
+    self.variation_variable_usage_map = {}
     for experiment in self.experiment_key_map.values():
       self.experiment_id_map[experiment.id] = experiment
       self.variation_key_map[experiment.key] = self._generate_key_map(
         experiment.variations, 'key', entities.Variation
       )
       self.variation_id_map[experiment.key] = {}
       for variation in self.variation_key_map.get(experiment.key).values():
-        feature_flag_to_value_map = self._map_feature_flag_to_value(variation.variables, self.feature_flag_id_map)
-        variation.featureFlagMap = feature_flag_to_value_map
         self.variation_id_map[experiment.key][variation.id] = variation
+        if variation.variables:
+          self.variation_variable_usage_map[variation.id] = self._generate_key_map(variation.variables, 'id', entities.Variation.VariableUsage)
+
+    self.feature_key_map = self._generate_key_map(self.features, 'key', entities.Feature)
+    for feature in self.feature_key_map.values():
+      feature.variables = self._generate_key_map(feature.variables, 'key', entities.Variable)
+
+      # Check if any of the experiments are in a group and add the group id for faster bucketing later on
+      for exp_id in feature.experimentIds:
+        experiment_in_feature = self.experiment_id_map[exp_id]
+        if experiment_in_feature.groupId:
+          feature.groupId = experiment_in_feature.groupId
+          # Experiments in feature can only belong to one mutex group
+          break
 
     self.parsing_succeeded = True
 
@@ -128,45 +146,25 @@ def _deserialize_audience(audience_map):
     return audience_map
 
   def _get_typecast_value(self, value, type):
-    """ Helper method to determine actual value based on type of feature flag.
+    """ Helper method to determine actual value based on type of feature variable.
 
     Args:
       value: Value in string form as it was parsed from datafile.
       type: Type denoting the feature flag type.
 
     Return:
-      Value type-casted based on type of feature flag.
+      Value type-casted based on type of feature variable.
     """
 
-    if type == entities.FeatureFlag.Type.BOOLEAN:
+    if type == entities.Variable.Type.BOOLEAN:
       return value == 'true'
-    elif type == entities.FeatureFlag.Type.INTEGER:
+    elif type == entities.Variable.Type.INTEGER:
       return int(value)
-    elif type == entities.FeatureFlag.Type.DOUBLE:
+    elif type == entities.Variable.Type.DOUBLE:
       return float(value)
     else:
       return value
 
-  def _map_feature_flag_to_value(self, variables, feature_flag_id_map):
-    """ Helper method to create map of feature flag key to associated value for a given variation's feature flag set.
-
-    Args:
-      variables: List of dicts representing variables on an instance of Variation object.
-      feature_flag_id_map: Dict mapping feature flag key to feature flag object.
-
-    Returns:
-      Dict mapping values from feature flag key to value stored on the variation's variable.
-    """
-
-    feature_flag_value_map = {}
-    for variable in variables:
-      feature_flag = feature_flag_id_map[variable.get('id')]
-      if not feature_flag:
-        continue
-      feature_flag_value_map[feature_flag.key] = self._get_typecast_value(variable.get('value'), feature_flag.type)
-
-    return feature_flag_value_map
-
   def was_parsing_successful(self):
     """ Helper method to determine if parsing the datafile was successful.
 
@@ -357,15 +355,6 @@ def get_event(self, event_key):
     self.error_handler.handle_error(exceptions.InvalidEventException(enums.Errors.INVALID_EVENT_KEY_ERROR))
     return None
 
-  def get_revenue_goal(self):
-    """ Get the revenue goal for the project.
-
-    Returns:
-      Revenue goal.
-    """
-
-    return self.get_event(REVENUE_GOAL_KEY)
-
   def get_attribute(self, attribute_key):
     """ Get attribute for the provided attribute key.
 
@@ -384,3 +373,84 @@ def get_attribute(self, attribute_key):
     self.logger.log(enums.LogLevels.ERROR, 'Attribute "%s" is not in datafile.' % attribute_key)
     self.error_handler.handle_error(exceptions.InvalidAttributeException(enums.Errors.INVALID_ATTRIBUTE_ERROR))
     return None
+
+  def get_feature_from_key(self, feature_key):
+    """ Get feature for the provided feature key.
+
+    Args:
+      feature_key: Feature key for which feature is to be fetched.
+
+    Returns:
+      Feature corresponding to the provided feature key.
+    """
+    feature = self.feature_key_map.get(feature_key)
+
+    if feature:
+      return feature
+
+    self.logger.log(enums.LogLevels.ERROR, 'Feature "%s" is not in datafile.' % feature_key)
+    return None
+
+  def get_layer_from_id(self, layer_id):
+    """ Get layer for the provided layer id.
+
+    Args:
+      layer_id: ID of the layer to be fetched.
+
+    Returns:
+      Layer corresponding to the provided layer id.
+    """
+    layer = self.layer_id_map.get(layer_id)
+
+    if layer:
+      return layer
+
+    self.logger.log(enums.LogLevels.ERROR, 'Layer with ID "%s" is not in datafile.' % layer_id)
+    return None
+
+  def get_variable_value_for_variation(self, variable, variation):
+    """ Get the variable value for the given variation.
+
+    Args:
+      Variable: The Variable for which we are getting the value.
+      Variation: The Variation for which we are getting the variable value.
+
+    Returns:
+      The type-casted variable value or None if any of the inputs are invalid.
+    """
+    if not variable or not variation:
+      return None
+
+    if variation.id not in self.variation_variable_usage_map:
+      self.logger.log(enums.LogLevels.ERROR, 'Variation with ID "%s" is not in the datafile.' % variation.id)
+      return None
+
+    # Get all variable usages for the given variation
+    variable_usages = self.variation_variable_usage_map[variation.id]
+
+    # Find usage in given variation
+    variable_usage = variable_usages[variable.id]
+
+    value = self._get_typecast_value(variable_usage.value, variable.type)
+    return value
+
+  def get_variable_for_feature(self, feature_key, variable_key):
+    """ Get the variable with the given variable key for the given feature
+
+    Args:
+      feature_key: The key of the feature for which we are getting the variable.
+      variable_key: The key of the variable we are getting.
+
+    Returns:
+      Variable with the given key in the given variation.
+    """
+    feature = self.feature_key_map.get(feature_key)
+    if not feature:
+      self.logger.log(enums.LogLevels.ERROR, 'Feature with key "%s" not found in the datafile.' % feature_key)
+      return None
+
+    if variable_key not in feature.variables:
+      self.logger.log(enums.LogLevels.ERROR, 'Variable with key "%s" not found in the datafile.' % variable_key)
+      return None
+
+    return feature.variables.get(variable_key)

tests/base.py

@@ -134,5 +134,105 @@ def setUp(self):
       'projectId': '111001'
     }
 
+    # datafile version 4
+    self.config_dict_with_features = {
+      'revision': '1',
+      'accountId': '12001',
+      'projectId': '111111',
+      'version': '4',
+      'events': [{
+        'key': 'test_event',
+        'experimentIds': ['111127'],
+        'id': '111095'
+      }],
+      'experiments': [{
+        'key': 'test_experiment',
+        'status': 'Running',
+        'forcedVariations': {},
+        'layerId': '111182',
+        'audienceIds': [],
+        'trafficAllocation': [{
+          'entityId': '111128',
+          'endOfRange': 5000
+        }, {
+          'entityId': '111129',
+          'endOfRange': 9000
+        }],
+        'id': '111127',
+        'variations': [{
+          'key': 'control',
+          'id': '111128',
+          'variables': [{
+            'id': '127', 'value': 'false'
+          }, {
+            'id': '128', 'value': 'prod'
+          }]
+        }, {
+          'key': 'variation',
+          'id': '111129'
+        }]
+      }],
+      'groups': [],
+      'attributes': [{
+        'key': 'test_attribute',
+        'id': '111094'
+      }],
+      'audiences': [{
+        'name': 'Test attribute users',
+        'conditions': '["and", ["or", ["or", '
+                      '{"name": "test_attribute", "type": "custom_attribute", "value": "test_value"}]]]',
+        'id': '11154'
+      }],
+      'layers': [{
+        'id': '211111',
+        'policy': 'ordered',
+        'experiments': [{
+          'key': 'test_rollout_exp_1',
+          'status': 'Running',
+          'forcedVariations': {},
+          'layerId': '211111',
+          'audienceIds': ['11154'],
+          'trafficAllocation': [{
+            'entityId': '211128',
+            'endOfRange': 5000
+          }, {
+            'entityId': '211129',
+            'endOfRange': 9000
+          }],
+          'id': '211127',
+          'variations': [{
+            'key': 'control',
+            'id': '211128'
+          }, {
+            'key': 'variation',
+            'id': '211129'
+          }]
+        }]
+      }],
+      'features': [{
+        'id': '91111',
+        'key': 'test_feature_1',
+        'experimentIds': ['111127'],
+        'layerId': '',
+        'variables': [{
+            'id': '127',
+            'key': 'is_working',
+            'defaultValue': 'true',
+            'type': 'boolean',
+          }, {
+            'id': '128',
+            'key': 'environment',
+            'defaultValue': 'devel',
+            'type': 'string',
+          }]
+      }, {
+        'id': '91112',
+        'key': 'test_feature_2',
+        'experimentIds': [],
+        'layerId': '211111',
+        'variables': [],
+      }]
+    }
+
     self.optimizely = optimizely.Optimizely(json.dumps(self.config_dict))
     self.project_config = self.optimizely.config