[AI-FSSDK] [FSSDK-12337] Add Feature Rollout support (#499)

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

* [AI-FSSDK] [FSSDK-12337] Fix test structure, mypy and ruff compliance

- Move feature rollout tests from standalone test_feature_rollout.py into
  test_config.py following module-level testing convention
- Use base.BaseTest instead of unittest.TestCase for consistency
- Fix mypy strict type errors in Variation construction using cast
- All checks pass: ruff, mypy --strict, pytest (941/941)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* [AI-FSSDK] [FSSDK-12337] Simplify feature rollout config parsing

- Inline _get_everyone_else_variation logic, remove unnecessary static method
- Use get_rollout_from_id() to match TDD pseudocode
- Remove isinstance check (rollout experiments are always dicts)
- Remove 3 unit tests for deleted helper method (edge cases already
  covered by integration-level tests)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* [AI-FSSDK] [FSSDK-12337] Restore _get_everyone_else_variation as method

- Restore as instance method matching TDD pseudocode structure
- Takes flag (FeatureFlag) param, calls get_rollout_from_id internally
- Caller simplified to: everyone_else_variation = self._get_everyone_else_variation(flag)

* [AI-FSSDK] [FSSDK-12337] Add ExperimentTypes constants for type field

- Add ExperimentTypes enum in helpers/enums.py with AB, MAB, CMAB, FEATURE_ROLLOUT
- Use ExperimentTypes.FEATURE_ROLLOUT constant in config parsing instead of raw string

* [AI-FSSDK] [FSSDK-12337] Type-restrict Experiment.type to ExperimentType

- Add ExperimentType Literal type in helpers/types.py: 'a/b', 'mab', 'cmab', 'feature_rollout'
- Change Experiment.type from Optional[str] to Optional[ExperimentType]

* [AI-FSSDK] [FSSDK-12337] Remove ExperimentTypes class, simplify type check

- Remove redundant ExperimentTypes class from enums.py (ExperimentType Literal suffices)
- Simplify getattr(experiment, 'type', None) to experiment.type

* [AI-FSSDK] [FSSDK-12337] Return Variation entity from _get_everyone_else_variation

- Build Variation entity once in helper, derive dict from it in caller
- Addresses PR review comment from jaeopt

* [AI-FSSDK] [FSSDK-12337] Remove redundant tests, keep 6 essential ones

Removed 7 tests that were covered by other tests:
- test_experiment_type_field_parsed (covered by injection test)
- test_feature_rollout_with_empty_rollout_experiments (similar to no_rollout)
- test_feature_rollout_multiple_experiments_mixed_types (covered by injection + unchanged)
- test_feature_rollout_flag_variations_map_includes_injected (subset of maps test)
- test_experiment_type_ab (just string assignment)
- test_feature_rollout_with_variables_on_everyone_else (edge case)
- test_existing_datafile_not_broken (covered by none_when_missing + unchanged)

* [AI-FSSDK] [FSSDK-12337] Add ExperimentTypes constant and targeted_delivery type

- Add ExperimentTypes class in enums.py with ab, mab, cmab, td, fr
- Add 'targeted_delivery' to ExperimentType Literal in types.py
- Use enums.ExperimentTypes.fr constant in injection check
- Add test for type field parsing from datafile

* [AI-FSSDK] [FSSDK-12337] Remove test not in ticket spec

Remove test_feature_rollout_everyone_else_is_last_rollout_rule
to match updated Jira ticket test requirements.

* [FSSDK-12337] Fix experiment type values to match backend

Update ExperimentTypes and ExperimentType Literal to use actual
backend values: 'multi_armed_bandit' and 'contextual_multi_armed_bandit'
instead of shorthand 'mab' and 'cmab'.

* Format ExperimentType definition for ruff check

* [AI-FSSDK] [FSSDK-12337] Update experiment type values to short-form abbreviations

* [AI-FSSDK] [FSSDK-12337] Add validation for experiment type field

* trigger CI

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: FarhanAnjum-opti

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]: