[AI-FSSDK] [FSSDK-12337] Add Feature Rollout support to project config parsing

Author: FarhanAnjum-opti

optimizely/entities.py

@@ -87,6 +87,7 @@ def __init__(
         groupId: Optional[str] = None,
         groupPolicy: Optional[str] = None,
         cmab: Optional[CmabDict] = None,
+        type: Optional[str] = None,
         **kwargs: Any
     ):
         self.id = id
@@ -101,6 +102,7 @@ def __init__(
         self.groupId = groupId
         self.groupPolicy = groupPolicy
         self.cmab = cmab
+        self.type = type
 
     def get_audience_conditions_or_ids(self) -> Sequence[str | list[str]]:
         """ Returns audienceConditions if present, otherwise audienceIds. """

optimizely/project_config.py

@@ -232,6 +232,34 @@ def __init__(self, datafile: str | bytes, logger: Logger, error_handler: Any):
                 self.experiment_feature_map[exp_id] = [feature.id]
                 rules.append(self.experiment_id_map[exp_id])
 
+            # Feature Rollout support: inject the "everyone else" variation
+            # into any experiment with type == "feature_rollout"
+            rollout_for_flag = (
+                None if len(feature.rolloutId) == 0
+                else self.rollout_id_map.get(feature.rolloutId)
+            )
+            if rollout_for_flag:
+                everyone_else_variation = self._get_everyone_else_variation(rollout_for_flag)
+                if everyone_else_variation is not None:
+                    for experiment in rules:
+                        if getattr(experiment, 'type', None) == 'feature_rollout':
+                            # Append the everyone else variation to the experiment
+                            experiment.variations.append(everyone_else_variation)
+                            # Add traffic allocation entry with endOfRange=10000
+                            experiment.trafficAllocation.append({
+                                'entityId': everyone_else_variation['id'],
+                                'endOfRange': 10000,
+                            })
+                            # Update variation maps for this experiment
+                            var_entity = entities.Variation(**everyone_else_variation)
+                            self.variation_key_map[experiment.key][var_entity.key] = var_entity
+                            self.variation_id_map[experiment.key][var_entity.id] = var_entity
+                            self.variation_id_map_by_experiment_id[experiment.id][var_entity.id] = var_entity
+                            self.variation_key_map_by_experiment_id[experiment.id][var_entity.key] = var_entity
+                            self.variation_variable_usage_map[var_entity.id] = self._generate_key_map(
+                                var_entity.variables, 'id', entities.Variation.VariableUsage
+                            )
+
             flag_id = feature.id
             applicable_holdouts: list[entities.Holdout] = []
 
@@ -304,6 +332,32 @@ def _generate_key_map(
 
         return key_map
 
+    @staticmethod
+    def _get_everyone_else_variation(rollout: entities.Layer) -> Optional[types.VariationDict]:
+        """ Get the "everyone else" variation from a rollout.
+
+        The "everyone else" rule is the last experiment in the rollout,
+        and its first variation is the "everyone else" variation.
+
+        Args:
+            rollout: The rollout (Layer) entity to get the variation from.
+
+        Returns:
+            The "everyone else" variation dict, or None if not available.
+        """
+        if not rollout.experiments:
+            return None
+
+        everyone_else_rule = rollout.experiments[-1]
+        variations = everyone_else_rule.get('variations', []) if isinstance(
+            everyone_else_rule, dict
+        ) else getattr(everyone_else_rule, 'variations', [])
+
+        if not variations:
+            return None
+
+        return variations[0]
+
     @staticmethod
     def _deserialize_audience(audience_map: dict[str, entities.Audience]) -> dict[str, entities.Audience]:
         """ Helper method to de-serialize and populate audience map with the condition list and structure.