[AI-FSSDK] [FSSDK-12368] Cleanup flag base setup (local holdouts) (#507)

* [FSSDK-12368] Remove legacy flag-level holdout fields

Remove deprecated flag-level holdout functionality as cleanup after
local holdouts (FSSDK-12369) implementation.

Changes:
- Removed includedFlags and excludedFlags from Holdout entity
- Removed includedFlags and excludedFlags from HoldoutDict type
- Removed get_holdouts_for_flag() method from ProjectConfig
- Removed flag-level holdout infrastructure:
  - global_holdouts list
  - included_holdouts dict
  - excluded_holdouts dict
  - flag_holdouts_map dict
  - Flag-level population logic in ProjectConfig.__init__
- Removed flag-level holdout checking from DecisionService.get_variation_for_feature()
- Removed 10 test methods testing removed functionality
- Removed includedFlags/excludedFlags from all test fixtures

Impact: 7 files modified, 310 lines deleted, 5 lines added (net: -305 lines)

Verification:
- grep for "includedFlags", "excludedFlags", "getHoldoutsForFlag" returns zero results
- grep for "global_holdouts", "included_holdouts", "excluded_holdouts", "flag_holdouts_map" returns zero results

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

* [FSSDK-12368] Restore holdout evaluation in decide flow, remove only flag-level include/exclude fields

The previous cleanup removed the entire holdout evaluation from the decide
flow. This restores holdout checking while keeping the removal of legacy
includedFlags/excludedFlags fields — all running holdouts now apply to all
flags uniformly.

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

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Co-authored-by: Farhan Anjum <Farhan.Anjum@optimizely.com>

Author: 3 people

optimizely/entities.py

@@ -222,8 +222,6 @@ def __init__(
         variations: list[VariationDict],
         trafficAllocation: list[TrafficAllocation],
         audienceIds: list[str],
-        includedFlags: Optional[list[str]] = None,
-        excludedFlags: Optional[list[str]] = None,
         audienceConditions: Optional[Sequence[str | list[str]]] = None,
         **kwargs: Any
     ):
@@ -234,8 +232,6 @@ def __init__(
         self.trafficAllocation = trafficAllocation
         self.audienceIds = audienceIds
         self.audienceConditions = audienceConditions
-        self.includedFlags = includedFlags or []
-        self.excludedFlags = excludedFlags or []
 
     def get_audience_conditions_or_ids(self) -> Sequence[str | list[str]]:
         """Returns audienceConditions if present, otherwise audienceIds.

optimizely/helpers/types.py

@@ -130,5 +130,3 @@ class HoldoutDict(ExperimentDict):
     Extends ExperimentDict with holdout-specific properties.
     """
     holdoutStatus: HoldoutStatus
-    includedFlags: list[str]
-    excludedFlags: list[str]

optimizely/project_config.py

@@ -93,9 +93,6 @@ def __init__(self, datafile: str | bytes, logger: Logger, error_handler: Any):
         holdouts_data: list[types.HoldoutDict] = config.get('holdouts', [])
         self.holdouts: list[entities.Holdout] = []
         self.holdout_id_map: dict[str, entities.Holdout] = {}
-        self.global_holdouts: list[entities.Holdout] = []
-        self.included_holdouts: dict[str, list[entities.Holdout]] = {}
-        self.excluded_holdouts: dict[str, list[entities.Holdout]] = {}
         self.flag_holdouts_map: dict[str, list[entities.Holdout]] = {}
 
         # Convert holdout dicts to Holdout entities
@@ -104,33 +101,13 @@ def __init__(self, datafile: str | bytes, logger: Logger, error_handler: Any):
             holdout = entities.Holdout(**holdout_data)
             self.holdouts.append(holdout)
 
-            # Only process Running holdouts but doing it here for efficiency like the original Python implementation)
+            # Only process Running holdouts
             if not holdout.is_activated:
                 continue
 
             # Map by ID for quick lookup
             self.holdout_id_map[holdout.id] = holdout
 
-            # Categorize as global vs flag-specific
-            # Global holdouts: apply to all flags unless explicitly excluded
-            # Flag-specific holdouts: only apply to explicitly included flags
-            if not holdout.includedFlags:
-                # This is a global holdout
-                self.global_holdouts.append(holdout)
-
-                # Track which flags this global holdout excludes
-                if holdout.excludedFlags:
-                    for flag_id in holdout.excludedFlags:
-                        if flag_id not in self.excluded_holdouts:
-                            self.excluded_holdouts[flag_id] = []
-                        self.excluded_holdouts[flag_id].append(holdout)
-            else:
-                # This holdout applies to specific flags only
-                for flag_id in holdout.includedFlags:
-                    if flag_id not in self.included_holdouts:
-                        self.included_holdouts[flag_id] = []
-                    self.included_holdouts[flag_id].append(holdout)
-
         # Utility maps for quick lookup
         self.group_id_map: dict[str, entities.Group] = self._generate_key_map(self.groups, 'id', entities.Group)
         self.experiment_id_map: dict[str, entities.Experiment] = self._generate_key_map(
@@ -263,19 +240,8 @@ def __init__(self, datafile: str | bytes, logger: Logger, error_handler: Any):
                             everyone_else_variation.variables, 'id', entities.Variation.VariableUsage
                         )
 
-            flag_id = feature.id
-            applicable_holdouts: list[entities.Holdout] = []
-
-            # Add global holdouts first, excluding any that are explicitly excluded for this flag
-            excluded_holdouts = self.excluded_holdouts.get(flag_id, [])
-            for holdout in self.global_holdouts:
-                if holdout not in excluded_holdouts:
-                    applicable_holdouts.append(holdout)
-
-            # Add flag-specific local holdouts AFTER global holdouts
-            if flag_id in self.included_holdouts:
-                applicable_holdouts.extend(self.included_holdouts[flag_id])
-
+            # Map all running holdouts to this flag
+            applicable_holdouts = list(self.holdout_id_map.values())
             if applicable_holdouts:
                 self.flag_holdouts_map[feature.key] = applicable_holdouts
 

tests/test_bucketing_holdout.py

@@ -62,8 +62,6 @@ def setUp(self):
                 'id': 'holdout_1',
                 'key': 'test_holdout',
                 'status': 'Running',
-                'includedFlags': [],
-                'excludedFlags': [],
                 'audienceIds': [],
                 'variations': [
                     {
@@ -92,8 +90,6 @@ def setUp(self):
                 'id': 'holdout_empty_1',
                 'key': 'empty_holdout',
                 'status': 'Running',
-                'includedFlags': [],
-                'excludedFlags': [],
                 'audienceIds': [],
                 'variations': [],
                 'trafficAllocation': []

tests/test_config.py

@@ -1384,96 +1384,37 @@ def setUp(self):
         # Create config with holdouts
         config_body_with_holdouts = self.config_dict_with_features.copy()
 
-        # Use correct feature flag IDs from the datafile
-        boolean_feature_id = '91111'  # boolean_single_variable_feature
-        multi_variate_feature_id = '91114'  # test_feature_in_experiment_and_rollout
-
         config_body_with_holdouts['holdouts'] = [
             {
                 'id': 'holdout_1',
                 'key': 'global_holdout',
                 'status': 'Running',
                 'variations': [],
                 'trafficAllocation': [],
-                'audienceIds': [],
-                'includedFlags': [],
-                'excludedFlags': [boolean_feature_id]
+                'audienceIds': []
             },
             {
                 'id': 'holdout_2',
                 'key': 'specific_holdout',
                 'status': 'Running',
                 'variations': [],
                 'trafficAllocation': [],
-                'audienceIds': [],
-                'includedFlags': [multi_variate_feature_id],
-                'excludedFlags': []
+                'audienceIds': []
             },
             {
                 'id': 'holdout_3',
                 'key': 'inactive_holdout',
                 'status': 'Inactive',
                 'variations': [],
                 'trafficAllocation': [],
-                'audienceIds': [],
-                'includedFlags': [boolean_feature_id],
-                'excludedFlags': []
+                'audienceIds': []
             }
         ]
 
         self.config_json_with_holdouts = json.dumps(config_body_with_holdouts)
         opt_obj = optimizely.Optimizely(self.config_json_with_holdouts)
         self.config_with_holdouts = opt_obj.config_manager.get_config()
 
-    def test_get_holdouts_for_flag__non_existent_flag(self):
-        """ Test that get_holdouts_for_flag returns empty array for non-existent flag. """
-
-        holdouts = self.config_with_holdouts.get_holdouts_for_flag('non_existent_flag')
-        self.assertEqual([], holdouts)
-
-    def test_get_holdouts_for_flag__returns_global_and_specific_holdouts(self):
-        """ Test that get_holdouts_for_flag returns global holdouts that do not exclude the flag
-        and specific holdouts that include the flag. """
-
-        holdouts = self.config_with_holdouts.get_holdouts_for_flag('test_feature_in_experiment_and_rollout')
-        self.assertEqual(2, len(holdouts))
-
-        global_holdout = next((h for h in holdouts if h['key'] == 'global_holdout'), None)
-        self.assertIsNotNone(global_holdout)
-        self.assertEqual('holdout_1', global_holdout['id'])
-
-        specific_holdout = next((h for h in holdouts if h['key'] == 'specific_holdout'), None)
-        self.assertIsNotNone(specific_holdout)
-        self.assertEqual('holdout_2', specific_holdout['id'])
-
-    def test_get_holdouts_for_flag__excludes_global_holdouts_for_excluded_flags(self):
-        """ Test that get_holdouts_for_flag does not return global holdouts that exclude the flag. """
-
-        holdouts = self.config_with_holdouts.get_holdouts_for_flag('boolean_single_variable_feature')
-        self.assertEqual(0, len(holdouts))
-
-        global_holdout = next((h for h in holdouts if h['key'] == 'global_holdout'), None)
-        self.assertIsNone(global_holdout)
-
-    def test_get_holdouts_for_flag__caches_results(self):
-        """ Test that get_holdouts_for_flag caches results for subsequent calls. """
-
-        holdouts1 = self.config_with_holdouts.get_holdouts_for_flag('test_feature_in_experiment_and_rollout')
-        holdouts2 = self.config_with_holdouts.get_holdouts_for_flag('test_feature_in_experiment_and_rollout')
-
-        # Should be the same object (cached)
-        self.assertIs(holdouts1, holdouts2)
-        self.assertEqual(2, len(holdouts1))
-
-    def test_get_holdouts_for_flag__returns_only_global_for_non_targeted_flags(self):
-        """ Test that get_holdouts_for_flag returns only global holdouts for flags not specifically targeted. """
-
-        holdouts = self.config_with_holdouts.get_holdouts_for_flag('test_feature_in_rollout')
-
-        # Should only include global holdout (not excluded and no specific targeting)
-        self.assertEqual(1, len(holdouts))
-        self.assertEqual('global_holdout', holdouts[0]['key'])
-
     def test_get_holdout__returns_holdout_for_valid_id(self):
         """ Test that get_holdout returns holdout when valid ID is provided. """
 
@@ -1516,36 +1457,6 @@ def test_get_holdout__does_not_log_when_found(self):
             self.assertIsNotNone(result)
             mock_logger.error.assert_not_called()
 
-    def test_holdout_initialization__categorizes_holdouts_properly(self):
-        """ Test that holdouts are properly categorized during initialization. """
-
-        self.assertIn('holdout_1', self.config_with_holdouts.holdout_id_map)
-        self.assertIn('holdout_2', self.config_with_holdouts.holdout_id_map)
-        # Check if a holdout with ID 'holdout_1' exists in global_holdouts
-        holdout_ids_in_global = [h.id for h in self.config_with_holdouts.global_holdouts]
-        self.assertIn('holdout_1', holdout_ids_in_global)
-
-        # Use correct feature flag IDs
-        boolean_feature_id = '91111'
-        multi_variate_feature_id = '91114'
-
-        self.assertIn(multi_variate_feature_id, self.config_with_holdouts.included_holdouts)
-        self.assertTrue(len(self.config_with_holdouts.included_holdouts[multi_variate_feature_id]) > 0)
-        self.assertNotIn(boolean_feature_id, self.config_with_holdouts.included_holdouts)
-
-        self.assertIn(boolean_feature_id, self.config_with_holdouts.excluded_holdouts)
-        self.assertTrue(len(self.config_with_holdouts.excluded_holdouts[boolean_feature_id]) > 0)
-
-    def test_holdout_initialization__only_processes_running_holdouts(self):
-        """ Test that only running holdouts are processed during initialization. """
-
-        self.assertNotIn('holdout_3', self.config_with_holdouts.holdout_id_map)
-        self.assertNotIn('holdout_3', self.config_with_holdouts.global_holdouts)
-
-        boolean_feature_id = '91111'
-        included_for_boolean = self.config_with_holdouts.included_holdouts.get(boolean_feature_id)
-        self.assertIsNone(included_for_boolean)
-
 
 class FeatureRolloutConfigTest(base.BaseTest):
     """Tests for Feature Rollout support in ProjectConfig parsing."""