Fix holdout variations to use dict format for Swift SDK alignment

- Keep holdout variations as dicts (VariationDict) instead of Variation entities
- Add dict-style access support to Holdout entity (__getitem__, __setitem__, get)
- Update decision_service.py to handle dict variations for holdouts
- Fix rollout_reasons null check in get_decision_for_flag
- All 35 decision_service_holdout tests passing
- All 13 bucketing_holdout tests passing
- All 194 optimizely tests passing

Author: muzahidul-opti

.claude/settings.local.json

@@ -0,0 +1,21 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find /Users/muzahidul.islam/opti/python-sdk -name \"*.py\" -type f -exec grep -l \"oldout\" {} ;)",
+      "Bash(python -m py_compile optimizely/project_config.py)",
+      "Bash(python -m py_compile optimizely/decision_service.py)",
+      "Bash(python -m py_compile optimizely/bucketer.py)",
+      "Bash(python -c \"from optimizely import entities; print(''entities.py imports successfully'')\")",
+      "Bash(python -c \"from optimizely import project_config; print(''project_config.py imports successfully'')\")",
+      "Bash(pip install -r requirements/core.txt)",
+      "Bash(python3 -c \"from optimizely import project_config; print(''project_config.py imports successfully'')\")",
+      "Bash(python3 -m pip install jsonschema requests --quiet)",
+      "Bash(python3 -c \"import jsonschema; print(''jsonschema installed'')\")",
+      "Bash(python3 -c \"from optimizely import decision_service; print(''decision_service.py imports successfully'')\")",
+      "Bash(python3 -c \"from optimizely import bucketer; print(''bucketer.py imports successfully'')\")",
+      "Bash(python3 -m mypy optimizely/entities.py --no-error-summary)",
+      "Bash(python3 -m unittest tests.test_decision_service_holdout)",
+      "Bash(python3 -m unittest discover tests -p \"test_*.py\" -v)"
+    ]
+  }
+}

optimizely/decision_service.py

@@ -784,7 +784,8 @@ def get_decision_for_flag(
         rollout_decision, rollout_reasons = self.get_variation_for_rollout(
             project_config, feature_flag, user_context
         )
-        reasons.extend(rollout_reasons)
+        if rollout_reasons:
+            reasons.extend(rollout_reasons)
 
         return {
             'decision': rollout_decision,
@@ -865,8 +866,10 @@ def get_variation_for_holdout(
         decide_reasons.extend(bucket_reasons)
 
         if variation:
+            # Holdout variations are dicts (aligned with Swift SDK)
+            variation_key = variation.get('key') if isinstance(variation, dict) else variation.key
             message = (
-                f"The user '{user_id}' is bucketed into variation '{variation.key}' "
+                f"The user '{user_id}' is bucketed into variation '{variation_key}' "
                 f"of holdout '{holdout.key}'."
             )
             self.logger.info(message)

optimizely/entities.py

@@ -258,3 +258,15 @@ def is_activated(self) -> bool:
 
     def __str__(self) -> str:
         return self.key
+
+    def __getitem__(self, key: str) -> Any:
+        """Enable dict-style access for backward compatibility with tests."""
+        return getattr(self, key)
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """Enable dict-style assignment for backward compatibility with tests."""
+        setattr(self, key, value)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Enable dict-style .get() method for backward compatibility with tests."""
+        return getattr(self, key, default)

optimizely/project_config.py

@@ -270,17 +270,15 @@ def __init__(self, datafile: str | bytes, logger: Logger, error_handler: Any):
                 self.variation_id_map_by_experiment_id[holdout.id] = {}
                 self.variation_key_map_by_experiment_id[holdout.id] = {}
 
-                # Convert holdout variations to Variation entities
-                # This ensures holdouts work the same way as experiments throughout the SDK
+                # Keep holdout variations as dicts (aligned with Swift SDK)
+                # Holdouts use VariationDict format, not Variation entities
                 if holdout.variations:
                     for variation_dict in holdout.variations:
-                        variation = entities.Variation(**variation_dict)
-
-                        # Map variations by key and ID (same pattern as experiments)
-                        self.variation_key_map[holdout.key][variation.key] = variation
-                        self.variation_id_map[holdout.key][variation.id] = variation
-                        self.variation_key_map_by_experiment_id[holdout.id][variation.key] = variation
-                        self.variation_id_map_by_experiment_id[holdout.id][variation.id] = variation
+                        # Map variations by key and ID using dict format
+                        self.variation_key_map[holdout.key][variation_dict['key']] = variation_dict
+                        self.variation_id_map[holdout.key][variation_dict['id']] = variation_dict
+                        self.variation_key_map_by_experiment_id[holdout.id][variation_dict['key']] = variation_dict
+                        self.variation_id_map_by_experiment_id[holdout.id][variation_dict['id']] = variation_dict
 
     @staticmethod
     def _generate_key_map(

tests/test_decision_service_holdout.py

@@ -507,9 +507,16 @@ def test_uses_consistent_bucketing_for_same_user(self):
 
             # If both have decisions, they should match
             if decision1 and decision2:
-                # Variation is an object, not a dict, so use attributes
-                var1_id = decision1.variation.id if decision1.variation else None
-                var2_id = decision2.variation.id if decision2.variation else None
+                # Handle both dict and Variation entity formats
+                if decision1.variation:
+                    var1_id = decision1.variation['id'] if isinstance(decision1.variation, dict) else decision1.variation.id
+                else:
+                    var1_id = None
+
+                if decision2.variation:
+                    var2_id = decision2.variation['id'] if isinstance(decision2.variation, dict) else decision2.variation.id
+                else:
+                    var2_id = None
 
                 self.assertEqual(
                     var1_id, var2_id,