[AI-FSSDK] [FSSDK-12337] Add Feature Rollout support

optimizely/entities.py

@@ -22,7 +22,7 @@
 
 if TYPE_CHECKING:
  # prevent circular dependenacy by skipping import at runtime
- from .helpers.types import ExperimentDict, TrafficAllocation, VariableDict, VariationDict, CmabDict
+ from .helpers.types import ExperimentDict, ExperimentType, TrafficAllocation, VariableDict, VariationDict, CmabDict
 
 
 class BaseEntity:
@@ -87,6 +87,7 @@ def __init__(
  groupId: Optional[str] = None,
  groupPolicy: Optional[str] = None,
  cmab: Optional[CmabDict] = None,
+ type: Optional[ExperimentType] = 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/helpers/enums.py

@@ -229,6 +229,14 @@ class OdpManagerConfig:
  EVENT_TYPE: Final = 'fullstack'
 
 
+class ExperimentTypes:
+ ab: Final = 'ab'
+ mab: Final = 'mab'
+ cmab: Final = 'cmab'
+ td: Final = 'td'
+ fr: Final = 'fr'
+
+
 class OdpSegmentsCacheConfig:
  """ODP Segment Cache configs."""
  DEFAULT_CAPACITY: Final = 10_000

optimizely/helpers/types.py

@@ -117,6 +117,10 @@ class CmabDict(BaseEntity):
  trafficAllocation: int
 
 
+ExperimentType = Literal[
+ 'ab', 'mab', 'cmab', 'td', 'fr'
+]
+
 HoldoutStatus = Literal['Draft', 'Running', 'Concluded', 'Archived']
 
 

optimizely/project_config.py

@@ -189,7 +189,24 @@ def __init__(self, datafile: str | bytes, logger: Logger, error_handler: Any):
  self.variation_key_map_by_experiment_id: dict[str, dict[str, Union[entities.Variation, VariationDict]]] = {}
  self.flag_variations_map: dict[str, list[entities.Variation]] = {}
 
+ valid_experiment_types = {
+ enums.ExperimentTypes.ab,
+ enums.ExperimentTypes.mab,
+ enums.ExperimentTypes.cmab,
+ enums.ExperimentTypes.td,
+ enums.ExperimentTypes.fr,
+ }
  for experiment in self.experiment_id_map.values():
+ if experiment.type is not None and experiment.type not in valid_experiment_types:
+ self.logger.error(
+ f'Experiment "{experiment.key}" has invalid type "{experiment.type}". '
+ f'Valid types: {valid_experiment_types}.'
+ )
+ self.error_handler.handle_error(
+ exceptions.InvalidExperimentException(
+ f'Invalid experiment type: {experiment.type}'
+ )
+ )
  self.experiment_key_map[experiment.key] = experiment
  self.variation_key_map[experiment.key] = self._generate_key_map(
  experiment.variations, 'key', entities.Variation
@@ -232,6 +249,37 @@ 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"
+ everyone_else_variation = self._get_everyone_else_variation(feature)
+ if everyone_else_variation is not None:
+ for experiment in rules:
+ if experiment.type == enums.ExperimentTypes.fr:
+ experiment.variations.append({
+ 'id': everyone_else_variation.id,
+ 'key': everyone_else_variation.key,
+ 'featureEnabled': everyone_else_variation.featureEnabled,
+ 'variables': cast(
+ list[types.VariableDict],
+ everyone_else_variation.variables,
+ ),
+ })
+ experiment.trafficAllocation.append({
+ 'entityId': everyone_else_variation.id,
+ 'endOfRange': 10000,
+ })
+ self.variation_key_map[experiment.key][everyone_else_variation.key] = everyone_else_variation
+ self.variation_id_map[experiment.key][everyone_else_variation.id] = everyone_else_variation
+ self.variation_id_map_by_experiment_id[experiment.id][everyone_else_variation.id] = (
+ everyone_else_variation
+ )
+ self.variation_key_map_by_experiment_id[experiment.id][everyone_else_variation.key] = (
+ everyone_else_variation
+ )
+ self.variation_variable_usage_map[everyone_else_variation.id] = self._generate_key_map(
+ everyone_else_variation.variables, 'id', entities.Variation.VariableUsage
+ )
+
  flag_id = feature.id
  applicable_holdouts: list[entities.Holdout] = []
 
@@ -667,6 +715,41 @@ def get_rollout_from_id(self, rollout_id: str) -> Optional[entities.Layer]:
  self.logger.error(f'Rollout with ID "{rollout_id}" is not in datafile.')
  return None
 
+ def _get_everyone_else_variation(self, flag: entities.FeatureFlag) -> Optional[entities.Variation]:
+ """ Get the "everyone else" variation for a feature flag.
+
+ The "everyone else" rule is the last experiment in the flag's rollout,
+ and its first variation is the "everyone else" variation.
+
+ Args:
+ flag: The feature flag to get the everyone else variation for.
+
+ Returns:
+ The "everyone else" Variation entity, or None if not available.
+ """
+ if not flag.rolloutId:
+ return None
+
+ rollout = self.get_rollout_from_id(flag.rolloutId)
+ if not rollout or not rollout.experiments:
+ return None
+
+ everyone_else_rule = rollout.experiments[-1]
+ variations = everyone_else_rule.get('variations', [])
+ if not variations:
+ return None
+
+ variation_dict = variations[0]
+ return entities.Variation(
+ id=variation_dict['id'],
+ key=variation_dict['key'],
+ featureEnabled=bool(variation_dict.get('featureEnabled', False)),
+ variables=cast(
+ Optional[list[entities.Variable]],
+ variation_dict.get('variables'),
+ ),
+ )
+
  def get_variable_value_for_variation(
  self, variable: Optional[entities.Variable], variation: Optional[Union[entities.Variation, VariationDict]]
  ) -> Optional[str]: