optimizely-sdk 5.4.0__tar.gz → 5.6.0__tar.gz

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Optimizely Python SDK Changelog
 
+## 5.6.0
+July 10th, 2026
+
+### New Features
+
+#### **Local Holdouts Support**
+
+- Added local holdouts support to the Python SDK, enabling flag-level traffic exclusion from experiments. ([#512](https://github.com/optimizely/python-sdk/pull/512))
+- Added `localHoldouts` datafile section parsing for backward compatibility with older datafile formats. ([#517](https://github.com/optimizely/python-sdk/pull/517))
+
+---
+
+### Bug Fixes
+
+- Fixed invalid IDs in holdout decision events by normalizing `campaign_id`, `variation_id`, and `entity_id` fields. ([#518](https://github.com/optimizely/python-sdk/pull/518))
+- Fixed CMAB prediction requests to use attribute ID instead of attribute key. ([#520](https://github.com/optimizely/python-sdk/pull/520))
+- Fixed ODP identify events being sent with a single identifier, which is a no-op. ([#513](https://github.com/optimizely/python-sdk/pull/513))
+
+---
+
+
+## 5.5.0
+April 30th, 2026
+
+### New Features
+
+#### **Feature Rollout Support**
+
+- Added support for Feature Rollouts, a new rule type that combines Targeted Delivery simplicity with A/B test measurement capabilities. During project config parsing, the "everyone else" variation from the flag's rollout is automatically injected into feature rollout experiments, enabling correct evaluation without changes to decision logic. ([#499](https://github.com/optimizely/python-sdk/pull/499))
+- Removed experiment type validation from config parsing to support flexible rule types. ([#500](https://github.com/optimizely/python-sdk/pull/500))
+
+---
+
+### Enhancements
+
+- Added event retry support for reliable event dispatching. ([#475](https://github.com/optimizely/python-sdk/pull/475))
+- Excluded CMAB experiments from UserProfileService to prevent stale cached decisions. ([#474](https://github.com/optimizely/python-sdk/pull/474))
+- Cleaned up flag-level holdout fields for simplified configuration. ([#507](https://github.com/optimizely/python-sdk/pull/507))
+
+---
+
+### Bug Fixes
+
+- Fixed `return` in `finally` block silently swallowing exceptions. ([#505](https://github.com/optimizely/python-sdk/pull/505))
+- Fixed `PollingConfigManager` rejecting valid URL-only configuration. ([#497](https://github.com/optimizely/python-sdk/pull/497))
+
+---
+
+
 ## 5.4.0
 December 19th, 2025
 

{optimizely-sdk-5.4.0/optimizely_sdk.egg-info → optimizely_sdk-5.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: optimizely-sdk
-Version: 5.4.0
+Version: 5.6.0
 Summary: Python SDK for Optimizely Feature Experimentation, Optimizely Full Stack (legacy), and Optimizely Rollouts.
 Home-page: https://github.com/optimizely/python-sdk
 Author: Optimizely
@@ -17,8 +17,34 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
-Provides-Extra: test
 License-File: LICENSE
+Requires-Dist: jsonschema>=3.2.0
+Requires-Dist: pyrsistent>=0.16.0
+Requires-Dist: requests>=2.21
+Requires-Dist: idna>=2.10
+Requires-Dist: rpds-py<0.20.0; python_version < "3.11"
+Provides-Extra: test
+Requires-Dist: pytest>=6.2.0; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: jsonschema>=3.2.0; extra == "test"
+Requires-Dist: pyrsistent>=0.16.0; extra == "test"
+Requires-Dist: requests>=2.21; extra == "test"
+Requires-Dist: rpds-py<0.20.0; python_version < "3.11" and extra == "test"
+Requires-Dist: python-coveralls; extra == "test"
+Requires-Dist: funcsigs>=0.4; extra == "test"
+Requires-Dist: idna>=2.10; extra == "test"
+Requires-Dist: ruff>=0.15.0; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 Optimizely Feature Experimentation is A/B testing and feature management for product development teams. Experiment in any application. Make every feature on your roadmap an opportunity to learn. Learn more at https://www.optimizely.com/products/experiment/feature-experimentation/ or see our documentation at https://docs.developers.optimizely.com/experimentation/v4.0.0-full-stack/docs/welcome. # Optimizely Python SDK
 
@@ -278,6 +304,55 @@ idna (BSD 3-Clause License https://github.com/kjd/idna/blob/master/LICENSE.md)
 - Swift - https://github.com/optimizely/swift-sdk
 # Optimizely Python SDK Changelog
 
+## 5.6.0
+July 10th, 2026
+
+### New Features
+
+#### **Local Holdouts Support**
+
+- Added local holdouts support to the Python SDK, enabling flag-level traffic exclusion from experiments. ([#512](https://github.com/optimizely/python-sdk/pull/512))
+- Added `localHoldouts` datafile section parsing for backward compatibility with older datafile formats. ([#517](https://github.com/optimizely/python-sdk/pull/517))
+
+---
+
+### Bug Fixes
+
+- Fixed invalid IDs in holdout decision events by normalizing `campaign_id`, `variation_id`, and `entity_id` fields. ([#518](https://github.com/optimizely/python-sdk/pull/518))
+- Fixed CMAB prediction requests to use attribute ID instead of attribute key. ([#520](https://github.com/optimizely/python-sdk/pull/520))
+- Fixed ODP identify events being sent with a single identifier, which is a no-op. ([#513](https://github.com/optimizely/python-sdk/pull/513))
+
+---
+
+
+## 5.5.0
+April 30th, 2026
+
+### New Features
+
+#### **Feature Rollout Support**
+
+- Added support for Feature Rollouts, a new rule type that combines Targeted Delivery simplicity with A/B test measurement capabilities. During project config parsing, the "everyone else" variation from the flag's rollout is automatically injected into feature rollout experiments, enabling correct evaluation without changes to decision logic. ([#499](https://github.com/optimizely/python-sdk/pull/499))
+- Removed experiment type validation from config parsing to support flexible rule types. ([#500](https://github.com/optimizely/python-sdk/pull/500))
+
+---
+
+### Enhancements
+
+- Added event retry support for reliable event dispatching. ([#475](https://github.com/optimizely/python-sdk/pull/475))
+- Excluded CMAB experiments from UserProfileService to prevent stale cached decisions. ([#474](https://github.com/optimizely/python-sdk/pull/474))
+- Cleaned up flag-level holdout fields for simplified configuration. ([#507](https://github.com/optimizely/python-sdk/pull/507))
+
+---
+
+### Bug Fixes
+
+- Fixed `return` in `finally` block silently swallowing exceptions. ([#505](https://github.com/optimizely/python-sdk/pull/505))
+- Fixed `PollingConfigManager` rejecting valid URL-only configuration. ([#497](https://github.com/optimizely/python-sdk/pull/497))
+
+---
+
+
 ## 5.4.0
 December 19th, 2025
 

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/cmab/cmab_service.py

@@ -163,7 +163,7 @@ class DefaultCmabService:
         for attribute_id in cmab_attribute_ids:
             attribute = project_config.attribute_id_map.get(attribute_id)
             if attribute and attribute.key in user_attributes:
-                filtered_user_attributes[attribute.key] = user_attributes[attribute.key]
+                filtered_user_attributes[attribute.id] = user_attributes[attribute.key]
 
         return filtered_user_attributes
 

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/config_manager.py

@@ -145,14 +145,14 @@ class StaticConfigManager(BaseConfigManager):
         except optimizely_exceptions.UnsupportedDatafileVersionException as error:
             error_msg = error.args[0]
             error_to_handle = error
-        except:
+        except Exception:
             error_msg = enums.Errors.INVALID_INPUT.format('datafile')
             error_to_handle = optimizely_exceptions.InvalidInputException(error_msg)
-        finally:
-            if error_msg or config is None:
-                self.logger.error(error_msg)
-                self.error_handler.handle_error(error_to_handle or Exception('Unknown Error'))
-                return
+
+        if error_msg or config is None:
+            self.logger.error(error_msg)
+            self.error_handler.handle_error(error_to_handle or Exception('Unknown Error'))
+            return
 
         previous_revision = self._config.get_revision() if self._config else None
 
@@ -236,9 +236,6 @@ class PollingConfigManager(StaticConfigManager):
         )
         self._sdk_key = sdk_key or self._sdk_key
 
-        if self._sdk_key is None:
-            raise optimizely_exceptions.InvalidInputException(enums.Errors.MISSING_SDK_KEY)
-
         self.datafile_url = self.get_datafile_url(
             self._sdk_key, url, url_template or self.DATAFILE_URL_TEMPLATE
         )

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/decision_service.py

@@ -515,6 +515,11 @@ class DecisionService:
                     'reasons': decide_reasons,
                     'variation': None
                 }
+            ignore_user_profile = True
+            self.logger.debug(
+                f'Skipping user profile service for CMAB experiment "{experiment.key}". '
+                f'CMAB decisions are dynamic and not stored for sticky bucketing.'
+            )
             variation_id = cmab_decision['variation_id'] if cmab_decision else None
             cmab_uuid = cmab_decision['cmab_uuid'] if cmab_decision else None
             variation = project_config.get_variation_from_id(experiment_key=experiment.key,
@@ -605,6 +610,24 @@ class DecisionService:
                 return Decision(experiment=rule, variation=forced_decision_variation,
                                 source=enums.DecisionSources.ROLLOUT, cmab_uuid=None), decide_reasons
 
+            # Check local holdouts targeting this specific delivery rule (FSSDK-12369)
+            local_holdouts = project_config.get_holdouts_for_rule(rule.id)
+            for holdout in local_holdouts:
+                local_holdout_decision = self.get_variation_for_holdout(
+                    holdout, user_context, project_config
+                )
+                decide_reasons.extend(local_holdout_decision['reasons'])
+
+                local_decision = local_holdout_decision['decision']
+                if local_decision.variation is not None:
+                    message = (
+                        f"The user '{user_id}' is bucketed into local holdout '{holdout.key}' "
+                        f"for delivery rule '{rule.key}'."
+                    )
+                    self.logger.info(message)
+                    decide_reasons.append(message)
+                    return local_decision, decide_reasons
+
             bucketing_id, bucket_reasons = self._get_bucketing_id(user_id, attributes)
             decide_reasons += bucket_reasons
 
@@ -728,9 +751,9 @@ class DecisionService:
         reasons = decide_reasons.copy() if decide_reasons else []
         user_id = user_context.user_id
 
-        # Check holdouts
-        holdouts = project_config.get_holdouts_for_flag(feature_flag.key)
-        for holdout in holdouts:
+        # Check global holdouts (flag level — before any rules are evaluated)
+        global_holdouts = project_config.get_global_holdouts()
+        for holdout in global_holdouts:
             holdout_decision = self.get_variation_for_holdout(holdout, user_context, project_config)
             reasons.extend(holdout_decision['reasons'])
 
@@ -751,7 +774,7 @@ class DecisionService:
                 'reasons': reasons
             }
 
-        # If no holdout decision, check experiments then rollouts
+        # If no global holdout decision, check experiments then rollouts
         if feature_flag.experimentIds:
             for experiment_id in feature_flag.experimentIds:
                 experiment = project_config.get_experiment_from_id(experiment_id)
@@ -773,6 +796,28 @@ class DecisionService:
                             'reasons': reasons
                         }
 
+                    # Check local holdouts targeting this specific experiment rule (FSSDK-12369)
+                    local_holdouts = project_config.get_holdouts_for_rule(experiment.id)
+                    for holdout in local_holdouts:
+                        local_holdout_decision = self.get_variation_for_holdout(
+                            holdout, user_context, project_config
+                        )
+                        reasons.extend(local_holdout_decision['reasons'])
+
+                        local_decision = local_holdout_decision['decision']
+                        if local_decision.variation is not None:
+                            message = (
+                                f"The user '{user_id}' is bucketed into local holdout '{holdout.key}' "
+                                f"for experiment rule '{experiment.key}'."
+                            )
+                            self.logger.info(message)
+                            reasons.append(message)
+                            return {
+                                'decision': local_holdout_decision['decision'],
+                                'error': False,
+                                'reasons': reasons
+                            }
+
                     # Get variation for experiment
                     variation_result = self.get_variation(
                         project_config, experiment, user_context, user_profile_tracker, reasons, decide_options

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/entities.py

@@ -87,6 +87,7 @@ class Experiment(BaseEntity):
         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 @@ class Experiment(BaseEntity):
         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. """
@@ -220,9 +222,8 @@ class Holdout(BaseEntity):
         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,
+        includedRules: Optional[list[str]] = None,
         **kwargs: Any
     ):
         self.id = id
@@ -232,8 +233,9 @@ class Holdout(BaseEntity):
         self.trafficAllocation = trafficAllocation
         self.audienceIds = audienceIds
         self.audienceConditions = audienceConditions
-        self.includedFlags = includedFlags or []
-        self.excludedFlags = excludedFlags or []
+        # Per-rule targeting for local holdouts. Scope comes from the datafile
+        # section, not this field; ProjectConfig strips it on 'holdouts' entries.
+        self.included_rules: Optional[list[str]] = includedRules
 
     def get_audience_conditions_or_ids(self) -> Sequence[str | list[str]]:
         """Returns audienceConditions if present, otherwise audienceIds.
@@ -243,6 +245,16 @@ class Holdout(BaseEntity):
         """
         return self.audienceConditions if self.audienceConditions is not None else self.audienceIds
 
+    @property
+    def is_global(self) -> bool:
+        """True if this is a global holdout.
+
+        Scope is set by the datafile section ('holdouts' vs 'localHoldouts').
+        ProjectConfig strips 'includedRules' on 'holdouts' entries, so this
+        property stays consistent with section membership.
+        """
+        return self.included_rules is None
+
     @property
     def is_activated(self) -> bool:
         """Check if the holdout is activated (running).

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/event/event_factory.py

@@ -1,4 +1,4 @@
-# Copyright 2019, 2022, Optimizely
+# Copyright 2019, 2022, 2026, Optimizely
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -18,6 +18,7 @@ from optimizely import entities
 from optimizely.helpers import enums
 from optimizely.helpers import event_tag_utils
 from optimizely.helpers import validator
+from . import event_id_normalizer
 from . import log_event
 from . import payload
 from . import user_event
@@ -134,12 +135,19 @@ class EventFactory:
                 if isinstance(event.experiment, entities.Experiment):
                     experiment_layerId = event.experiment.layerId
 
+            normalized_campaign_id = event_id_normalizer.normalize_campaign_id(
+                experiment_layerId, experiment_id
+            )
+            normalized_variation_id = event_id_normalizer.normalize_variation_id(variation_id)
+
             metadata = payload.Metadata(event.flag_key, event.rule_key,
                                         event.rule_type, variation_key,
                                         event.enabled, event.cmab_uuid)
-            decision = payload.Decision(experiment_layerId, experiment_id, variation_id, metadata)
+            decision = payload.Decision(
+                normalized_campaign_id, experiment_id, normalized_variation_id, metadata
+            )
             snapshot_event = payload.SnapshotEvent(
-                experiment_layerId, event.uuid, cls.ACTIVATE_EVENT_KEY, event.timestamp,
+                normalized_campaign_id, event.uuid, cls.ACTIVATE_EVENT_KEY, event.timestamp,
             )
 
             snapshot = payload.Snapshot([snapshot_event], [decision])

optimizely_sdk-5.6.0/optimizely/event/event_id_normalizer.py

@@ -0,0 +1,93 @@
+# Copyright 2026, Optimizely
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Normalization helpers for decision-event ID fields.
+
+This module provides byte-equivalent, cross-SDK normalization for the
+``campaign_id``, ``variation_id``, and impression ``entity_id`` fields that
+appear in dispatched decision events.
+
+Rules:
+  * ``campaign_id`` and impression ``entity_id`` accept **any non-empty
+    string** (numeric like ``"12345"`` or opaque like ``"default-12345"`` /
+    ``"layer_abc"``). The fallback to ``experiment_id`` fires ONLY when the
+    value is the empty string, ``None``, or missing. Non-string types are
+    out of scope for this normalization path (the upstream datafile
+    producer delivers string or null values).
+  * ``variation_id`` retains the stricter contract: it MUST be a non-empty
+    string of decimal digits ``0-9`` (leading zeros allowed). Empty,
+    whitespace, non-string, and non-numeric inputs are normalized to
+    ``None`` so the wire payload carries an explicit null.
+  * ``entity_id`` on impression events shares the campaign_id normalization
+    and is therefore byte-equivalent to the normalized campaign_id for the
+    same impression.
+
+The normalization path MUST NOT log, warn, or raise. It must never drop or
+defer event dispatch.
+"""
+
+
+from sys import version_info
+from typing import Any, Optional
+
+if version_info < (3, 10):
+    from typing_extensions import TypeGuard
+else:
+    from typing import TypeGuard
+
+
+def is_non_empty_string(value: Any) -> TypeGuard[str]:
+    """Return ``True`` if ``value`` is a non-empty :class:`str`.
+    Any non-empty string is accepted regardless of
+    character content (IDs may be opaque, e.g. ``"default-12345"``).
+    """
+    return isinstance(value, str) and value != ''
+
+
+def is_numeric_id_string(value: Any) -> TypeGuard[str]:
+    """Return ``True`` if ``value`` is a non-empty decimal-digit string.
+    Whitespace, signs, decimal points, exponents
+    and non-string types all return ``False``. Leading
+    zeros are accepted.
+    """
+    if not isinstance(value, str):
+        return False
+    if value == '':
+        return False
+    return value.isascii() and value.isdigit()
+
+
+def normalize_campaign_id(campaign_id: Any, experiment_id: Any) -> str:
+    """Normalize a decision-event ``campaign_id``.
+
+    Returns ``campaign_id`` unchanged when it is a non-empty string (any
+    character content — numeric like ``"12345"`` or opaque like
+    ``"default-12345"``). Otherwise falls back to ``experiment_id`` (when it
+    is itself a non-empty string). If neither is a non-empty string, returns
+    an empty string so the event still dispatches.
+    """
+    if is_non_empty_string(campaign_id):
+        return campaign_id
+    if is_non_empty_string(experiment_id):
+        return experiment_id
+    return ''
+
+
+def normalize_variation_id(variation_id: Any) -> Optional[str]:
+    """Normalize a decision-event ``variation_id``.
+
+    Returns the original value if it is a valid numeric ID string. Otherwise
+    returns ``None`` so the event payload carries an explicit null for the
+    downstream consumer.
+    """
+    return variation_id if is_numeric_id_string(variation_id) else None

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/event/payload.py

@@ -1,4 +1,4 @@
-# Copyright 2019, 2022, Optimizely
+# Copyright 2019, 2022, 2026, Optimizely
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -71,7 +71,13 @@ class EventBatch:
 class Decision:
     """ Class respresenting Decision. """
 
-    def __init__(self, campaign_id: str, experiment_id: str, variation_id: str, metadata: Metadata):
+    def __init__(
+        self,
+        campaign_id: str,
+        experiment_id: str,
+        variation_id: Optional[str],
+        metadata: Metadata,
+    ):
         self.campaign_id = campaign_id
         self.experiment_id = experiment_id
         self.variation_id = variation_id

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/event_builder.py

@@ -1,4 +1,4 @@
-# Copyright 2016-2019, 2022, Optimizely
+# Copyright 2016-2019, 2022, 2026, Optimizely
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
@@ -18,6 +18,7 @@ import uuid
 from sys import version_info
 
 from . import version
+from .event import event_id_normalizer
 from .helpers import enums
 from .helpers import event_tag_utils
 from .helpers import validator
@@ -178,7 +179,7 @@ class EventBuilder:
 
     def _get_required_params_for_impression(
         self, experiment: Experiment, variation_id: str
-    ) -> dict[str, list[dict[str, str | int]]]:
+    ) -> dict[str, list[dict[str, Any]]]:
         """ Get parameters that are required for the impression event to register.
 
     Args:
@@ -188,19 +189,24 @@ class EventBuilder:
     Returns:
       Dict consisting of decisions and events info for impression event.
     """
-        snapshot: dict[str, list[dict[str, str | int]]] = {}
+        snapshot: dict[str, list[dict[str, Any]]] = {}
+
+        normalized_campaign_id = event_id_normalizer.normalize_campaign_id(
+            experiment.layerId, experiment.id
+        )
+        normalized_variation_id = event_id_normalizer.normalize_variation_id(variation_id)
 
         snapshot[self.EventParams.DECISIONS] = [
             {
                 self.EventParams.EXPERIMENT_ID: experiment.id,
-                self.EventParams.VARIATION_ID: variation_id,
-                self.EventParams.CAMPAIGN_ID: experiment.layerId,
+                self.EventParams.VARIATION_ID: normalized_variation_id,
+                self.EventParams.CAMPAIGN_ID: normalized_campaign_id,
             }
         ]
 
         snapshot[self.EventParams.EVENTS] = [
             {
-                self.EventParams.EVENT_ID: experiment.layerId,
+                self.EventParams.EVENT_ID: normalized_campaign_id,
                 self.EventParams.TIME: self._get_time(),
                 self.EventParams.KEY: 'campaign_activated',
                 self.EventParams.UUID: str(uuid.uuid4()),

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/event_dispatcher.py

@@ -49,7 +49,7 @@ class EventDispatcher:
             session = requests.Session()
 
             retries = Retry(total=EventDispatchConfig.RETRIES,
-                            backoff_factor=0.1,
+                            backoff_factor=0.2,
                             status_forcelist=[500, 502, 503, 504])
             adapter = HTTPAdapter(max_retries=retries)
 

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/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-sdk-5.4.0 → optimizely_sdk-5.6.0}/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']
 
 
@@ -126,5 +130,6 @@ class HoldoutDict(ExperimentDict):
     Extends ExperimentDict with holdout-specific properties.
     """
     holdoutStatus: HoldoutStatus
-    includedFlags: list[str]
-    excludedFlags: list[str]
+    # Per-rule targeting for local holdouts. Scope comes from the datafile section,
+    # not this field; required on 'localHoldouts' entries, stripped on 'holdouts'.
+    includedRules: Optional[list[str]]

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/helpers/validator.py

@@ -193,7 +193,7 @@ def is_user_profile_valid(user_profile: dict[str, Any]) -> bool:
     if not user_profile:
         return False
 
-    if not type(user_profile) is dict:
+    if type(user_profile) is not dict:
         return False
 
     if UserProfile.USER_ID_KEY not in user_profile:
@@ -203,7 +203,7 @@ def is_user_profile_valid(user_profile: dict[str, Any]) -> bool:
         return False
 
     experiment_bucket_map = user_profile.get(UserProfile.EXPERIMENT_BUCKET_MAP_KEY)
-    if not type(experiment_bucket_map) is dict:
+    if type(experiment_bucket_map) is not dict:
         return False
 
     for decision in experiment_bucket_map.values():

{optimizely-sdk-5.4.0 → optimizely_sdk-5.6.0}/optimizely/odp/odp_event_manager.py

@@ -163,6 +163,8 @@ class OdpEventManager:
 
         self.logger.debug(f'ODP event queue: flushing batch size {batch_len}.')
         should_retry = False
+        initial_retry_interval = 0.2  # 200ms
+        max_retry_interval = 1.0  # 1 second
 
         for i in range(1 + self.retry_count):
             try:
@@ -176,7 +178,12 @@ class OdpEventManager:
             if not should_retry:
                 break
             if i < self.retry_count:
-                self.logger.debug('Error dispatching ODP events, scheduled to retry.')
+                # Exponential backoff: 200ms, 400ms, 800ms, ... capped at 1s
+                delay = initial_retry_interval * (2 ** i)
+                if delay > max_retry_interval:
+                    delay = max_retry_interval
+                self.logger.debug(f'Error dispatching ODP events, retrying after {delay}s.')
+                time.sleep(delay)
 
         if should_retry:
             self.logger.error(Errors.ODP_EVENT_FAILED.format(f'Failed after {i} retries: {self._current_batch}'))
@@ -260,9 +267,30 @@ class OdpEventManager:
         except Full:
             self.logger.warning(Errors.ODP_EVENT_FAILED.format("Queue is full"))
 
-    def identify_user(self, user_id: str) -> None:
+    def identify_user(self, identifiers: dict[str, str]) -> None:
+        """Send an identify event to ODP if there are multiple valid identifiers.
+
+        An identify event is only useful when there are two or more identifiers
+        to link together in the ODP user profile. Sending a single identifier
+        provides no linking value and wastes a network call.
+
+        Args:
+            identifiers: A dictionary of identifier key-value pairs
+                (e.g. {"fs_user_id": "abc", "email": "a@b.com"}).
+        """
+        # Filter out identifiers with None or empty string values.
+        valid_identifiers = {k: v for k, v in identifiers.items() if v}
+
+        # Identify requires 2+ identifiers to link (e.g., vuid + fs_user_id).
+        # A single identifier has no cross-reference value and generates unnecessary traffic.
+        if len(valid_identifiers) < 2:
+            self.logger.debug(
+                'ODP identify event is not dispatched (fewer than 2 valid identifiers).'
+            )
+            return
+
         self.send_event(OdpManagerConfig.EVENT_TYPE, 'identified',
-                        {OdpManagerConfig.KEY_FOR_USER_ID: user_id}, {})
+                        valid_identifiers, {})
 
     def update_config(self) -> None:
         """Adds update config signal to event_queue."""