flagsmith 6.1.0__tar.gz → 6.2.0__tar.gz

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

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

{flagsmith-6.1.0 → flagsmith-6.2.0}/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.0}/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.0}/flagsmith/models.py

@@ -52,6 +52,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 +67,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 +82,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"),
         )
 
 

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

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