flagsmith 6.1.0__tar.gz → 6.2.1__tar.gz

{flagsmith-6.1.0 → flagsmith-6.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flagsmith
-Version: 6.1.0
+Version: 6.2.1
 Summary: Flagsmith Python SDK
 License: BSD3
 License-File: LICENSE

{flagsmith-6.1.0 → flagsmith-6.2.1}/flagsmith/analytics.py

@@ -83,6 +83,12 @@ class AnalyticsProcessor:
             self.flush()
 
 
+class ExposureKey(typing.NamedTuple):
+    feature_name: typing.Optional[str]
+    identifier: typing.Optional[str]
+    value: typing.Optional[str]
+
+
 @dataclass
 class EventProcessorConfig:
     events_api_url: str = DEFAULT_EVENT_API_URL
@@ -111,6 +117,7 @@ class EventProcessor:
         self._flush_interval_seconds = config.flush_interval_seconds
 
         self._buffer: typing.List[typing.Dict[str, typing.Any]] = []
+        self._buffered_exposure_keys: typing.Set[ExposureKey] = set()
         self._lock = threading.Lock()
         self._timer: typing.Optional[threading.Timer] = None
 
@@ -159,6 +166,24 @@ class EventProcessor:
     ) -> None:
         should_flush = False
         with self._lock:
+            if event == FLAG_EXPOSURE_EVENT:
+                # An exposure is defined by who saw which variant of which
+                # feature; equal exposures within one flush interval add no
+                # information, so only the first is buffered.
+                exposure_key = ExposureKey(
+                    feature_name=feature_name,
+                    identifier=identifier,
+                    value=str(value) if value is not None else None,
+                )
+                if exposure_key in self._buffered_exposure_keys:
+                    logger.debug(
+                        "Skipping duplicate %s event for feature %s, identifier %s",
+                        FLAG_EXPOSURE_EVENT,
+                        feature_name,
+                        identifier,
+                    )
+                    return
+                self._buffered_exposure_keys.add(exposure_key)
             self._buffer.append(
                 {
                     "event": event,
@@ -182,6 +207,7 @@ class EventProcessor:
                 return
             events = self._buffer
             self._buffer = []
+            self._buffered_exposure_keys.clear()
 
         payload = json.dumps({"events": events})
         try:

{flagsmith-6.1.0 → flagsmith-6.2.1}/flagsmith/flagsmith.py

@@ -368,19 +368,38 @@ class Flagsmith:
         """
         Resolve a flag for an identity and record an exposure event.
 
-        Skips the exposure event when the resolved flag is a `DefaultFlag`
-        (i.e. the feature was not present and was served via the
-        `default_flag_handler`) or when the feature is disabled, to keep
-        experimentation data clean.
+        The exposure event's ``value`` is the flag's variant key. It is only
+        sent when the flag exists, is enabled and carries a variant; any
+        other outcome is logged and skipped to keep experimentation data
+        clean. A `DefaultFlag` served via the `default_flag_handler` counts
+        as the feature not existing.
         """
         if not self._event_processor:
             raise ValueError("Events must be enabled to use experiment flags.")
         flag = self.get_identity_flags(identifier, traits).get_flag(feature_name)
-        if isinstance(flag, Flag) and flag.enabled:
+        if not isinstance(flag, Flag):
+            logger.debug(
+                "Not sending %s for feature %s: feature not found.",
+                FLAG_EXPOSURE_EVENT,
+                feature_name,
+            )
+        elif not flag.enabled:
+            logger.debug(
+                "Not sending %s for feature %s: feature is disabled.",
+                FLAG_EXPOSURE_EVENT,
+                feature_name,
+            )
+        elif flag.variant is None:
+            logger.debug(
+                "Not sending %s for feature %s: flag has no variant.",
+                FLAG_EXPOSURE_EVENT,
+                feature_name,
+            )
+        else:
             self.track_exposure_event(
                 feature_name=feature_name,
                 identifier=identifier,
-                value=flag.variant if flag.variant is not None else flag.value,
+                value=flag.variant,
                 traits=traits,
             )
         return flag
@@ -418,6 +437,14 @@ class Flagsmith:
     ) -> None:
         if not self._event_processor:
             raise ValueError("Events must be enabled to track exposure events.")
+        if not identifier:
+            logger.warning(
+                "Not sending %s for feature %s: an exposure requires an"
+                " identifier to reconcile with conversion events.",
+                FLAG_EXPOSURE_EVENT,
+                feature_name,
+            )
+            return
         self._event_processor.track_exposure_event(
             feature_name=feature_name,
             identifier=identifier,

{flagsmith-6.1.0 → flagsmith-6.2.1}/flagsmith/mappers.py

@@ -177,7 +177,7 @@ def _map_identity_overrides_to_segments(
         # Generate a unique key to avoid collisions
         segment_key = str(hash(overrides_key))
         segment_contexts[segment_key] = SegmentContext(
-            key="",  # Identity override segments never use % Split operator
+            key=segment_key,
             name="identity_overrides",
             rules=[
                 {

{flagsmith-6.1.0 → flagsmith-6.2.1}/flagsmith/models.py

@@ -17,7 +17,7 @@ from flagsmith.types import (
 )
 
 SegmentOverridesIndex = typing.Dict[
-    str, typing.List[SegmentContext[SegmentMetadata, FeatureMetadata]]
+    str, typing.Dict[str, SegmentContext[SegmentMetadata, FeatureMetadata]]
 ]
 
 
@@ -28,11 +28,16 @@ def build_segment_overrides_index(
 
     Computed once per environment-document refresh so the lazy eval path
     can walk only the segments actually relevant to a given flag.
+
+    Each entry keeps the context's own segment keys, so the trimmed
+    contexts built by `Flags._resolve_flag` stay a faithful subset of
+    the environment. Re-keying them by anything else risks collisions
+    silently dropping segments.
     """
     index: SegmentOverridesIndex = {}
-    for segment_context in (context.get("segments") or {}).values():
+    for segment_key, segment_context in (context.get("segments") or {}).items():
         for override in segment_context.get("overrides") or ():
-            index.setdefault(override["name"], []).append(segment_context)
+            index.setdefault(override["name"], {})[segment_key] = segment_context
     return index
 
 
@@ -52,6 +57,7 @@ class Flag(BaseFlag):
     feature_id: int
     feature_name: str
     variant: typing.Optional[str] = None
+    reason: typing.Optional[str] = None
     is_default: bool = field(default=False)
 
     @classmethod
@@ -66,6 +72,7 @@ class Flag(BaseFlag):
                 feature_name=flag_result["name"],
                 feature_id=metadata["id"],
                 variant=flag_result.get("variant"),
+                reason=flag_result["reason"],
             )
         raise ValueError(
             "FlagResult metadata is missing. Cannot create Flag instance. "
@@ -80,6 +87,7 @@ class Flag(BaseFlag):
             feature_name=flag_data["feature"]["name"],
             feature_id=flag_data["feature"]["id"],
             variant=flag_data.get("variant"),
+            reason=flag_data.get("reason"),
         )
 
 
@@ -251,10 +259,7 @@ class Flags:
         trimmed: SDKEvaluationContext = {
             **context,
             "features": {feature_name: context["features"][feature_name]},
-            "segments": {
-                segment_context["key"]: segment_context
-                for segment_context in overrides_index.get(feature_name, ())
-            },
+            "segments": overrides_index.get(feature_name, {}),
         }
         result = engine.get_evaluation_result(trimmed)
         return Flag.from_evaluation_result(result["flags"][feature_name])

{flagsmith-6.1.0 → flagsmith-6.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "flagsmith"
-version = "6.1.0"
+version = "6.2.1"
 description = "Flagsmith Python SDK"
 authors = ["Flagsmith <support@flagsmith.com>"]
 license = "BSD3"