wingify-fme-python-sdk 1.55.0__tar.gz → 1.61.0__tar.gz

{wingify_fme_python_sdk-1.55.0/wingify_fme_python_sdk.egg-info → wingify_fme_python_sdk-1.61.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wingify-fme-python-sdk
-Version: 1.55.0
+Version: 1.61.0
 Summary: Wingify Feature Management and Experimentation SDK for Python
 Home-page: https://github.com/wingify/vwo-fme-python-sdk
 Author: Wingify
@@ -168,9 +168,30 @@ context = {
     'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
     'ip_address': '1.1.1.1',
     'session_id': 1697123456  # Optional: Custom session ID for web client integration
+    'platformVariables': {
+        # Reference example only:.
+        # In production, fetch campaign assignments using script run in frontend and pass that object to backend as webTestingCampaigns.
+        'webTestingCampaigns': '{"122":"1","130":"2"}'
+    },
+    'session_id': 1697123456  # Optional: Custom session ID for web client integration
 }
 ```
 
+## Web testing pre-segmentation
+
+Server-side flag decisions can align with **Web Testing** (browser) experiments. **Campaign assignments are typically read on the frontend** (for example, VWO cookies) and sent to your server; pass them in `platformVariables.webTestingCampaigns` as a map of **campaign ID -> variation ID** (strings), or as a **JSON string** of that object.
+
+Pre-segment rules in the VWO dashboard can use the **`campaignVariation`** operator:
+
+| Operand pattern | Meaning |
+| --------------- | ------- |
+| `C` | User is in campaign `C` (any variation). |
+| `!C` | User is **not** in campaign `C`. |
+| `C_V` | User is in campaign `C` with variation `V`. |
+| `C_!V` | User is in campaign `C` and assigned variation is **not** `V`. |
+
+Rollout rules evaluate pre-segments from the **first variation** only; AB/testing rules use **campaign-level** segments.
+
 ## Session Management
 
 The SDK provides automatic session management capabilities to enable seamless integration with VWO's web client testing campaigns. Session IDs are automatically generated and managed to connect server-side feature flag decisions with client-side user sessions.

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/README.md

@@ -141,9 +141,30 @@ context = {
     'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
     'ip_address': '1.1.1.1',
     'session_id': 1697123456  # Optional: Custom session ID for web client integration
+    'platformVariables': {
+        # Reference example only:.
+        # In production, fetch campaign assignments using script run in frontend and pass that object to backend as webTestingCampaigns.
+        'webTestingCampaigns': '{"122":"1","130":"2"}'
+    },
+    'session_id': 1697123456  # Optional: Custom session ID for web client integration
 }
 ```
 
+## Web testing pre-segmentation
+
+Server-side flag decisions can align with **Web Testing** (browser) experiments. **Campaign assignments are typically read on the frontend** (for example, VWO cookies) and sent to your server; pass them in `platformVariables.webTestingCampaigns` as a map of **campaign ID -> variation ID** (strings), or as a **JSON string** of that object.
+
+Pre-segment rules in the VWO dashboard can use the **`campaignVariation`** operator:
+
+| Operand pattern | Meaning |
+| --------------- | ------- |
+| `C` | User is in campaign `C` (any variation). |
+| `!C` | User is **not** in campaign `C`. |
+| `C_V` | User is in campaign `C` with variation `V`. |
+| `C_!V` | User is in campaign `C` and assigned variation is **not** `V`. |
+
+Rollout rules evaluate pre-segments from the **first variation** only; AB/testing rules use **campaign-level** segments.
+
 ## Session Management
 
 The SDK provides automatic session management capabilities to enable seamless integration with VWO's web client testing campaigns. Session IDs are automatically generated and managed to connect server-side feature flag decisions with client-side user sessions.

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/setup.py

@@ -143,7 +143,7 @@ class PostDevelopCommand(develop):
 
 setup(
     name=_brand["name"],
-    version="1.55.0",
+    version="1.61.0",
     description=_brand["description"],
     long_description=long_description,
     long_description_content_type="text/markdown",

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/api/get_flag_api.py

@@ -41,7 +41,11 @@ from ..utils.impression_util import (
 from ..models.user.get_flag import GetFlag
 from ..services.storage_service import StorageService
 from ..decorators.storage_decorator import StorageDecorator
-from ..utils.campaign_util import get_variation_from_campaign_key
+from ..utils.campaign_util import (
+    get_experiment_key,
+    get_rollout_key,
+    get_variation_from_campaign_key,
+)
 from ..enums.debug_category_enum import DebugCategoryEnum
 from ..packages.logger.enums.log_level_enum import LogLevelEnum
 from ..constants.Constants import Constants
@@ -392,7 +396,7 @@ class GetFlagApi:
 
                     self._evaluated_feature_map[feature_key] = {
                         "rolloutId": rule.get_id(),
-                        "rolloutKey": rule.get_key(),
+                        "rolloutKey": get_rollout_key(rule, feature_key),
                         "rolloutVariationId": (
                             rule.get_variations()[0].get_id()
                             if rule.get_variations()
@@ -493,7 +497,9 @@ class GetFlagApi:
                         self._passed_rules_information.update(
                             {
                                 "experimentId": rule.get_id(),
-                                "experimentKey": rule.get_key(),
+                                "experimentKey": get_experiment_key(
+                                    rule, feature.get_key()
+                                ),
                                 "experimentVariationId": whitelisted_object[
                                     "variationId"
                                 ],
@@ -627,7 +633,9 @@ class GetFlagApi:
             self._passed_rules_information.update(
                 {
                     "rolloutId": campaign.get_id(),
-                    "rolloutKey": campaign.get_key(),
+                    "rolloutKey": get_rollout_key(
+                        campaign, decision.get("featureKey")
+                    ),
                     "rolloutVariationId": variation.get_id(),
                 }
             )
@@ -635,7 +643,9 @@ class GetFlagApi:
             self._passed_rules_information.update(
                 {
                     "experimentId": campaign.get_id(),
-                    "experimentKey": campaign.get_key(),
+                    "experimentKey": get_experiment_key(
+                        campaign, decision.get("featureKey")
+                    ),
                     "experimentVariationId": variation.get_id(),
                 }
             )

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/constants/Constants.py

@@ -17,7 +17,7 @@ class Constants:
     # TODO: read from setup.py
     sdk_meta = {
         "name": "vwo-fme-python-sdk",
-        "version": "1.55.0",
+        "version": "1.61.0",
     }
 
     SDK_VERSION = sdk_meta["version"]

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/models/user/context_model.py

@@ -14,7 +14,8 @@
 
 
 from .context_vwo_model import ContextVWOModel
-from typing import Dict, List
+from typing import Any, Dict, List, Optional
+from ...utils.data_type_util import is_object
 from ...utils.uuid_util import get_uuid
 from ...services.settings_manager import SettingsManager
 from ...utils.function_util import get_current_unix_timestamp
@@ -33,6 +34,11 @@ class ContextModel:
         self._vwo = ContextVWOModel(vwo_context_data) if vwo_context_data else None
         self.post_segmentation_variables = context.get("post_segmentation_variables", [])
         self.bucketingSeed = context.get("bucketingSeed")
+        self.platform_variables: Optional[Dict[str, Any]] = (
+            dict(context.get("platform_variables"))
+            if is_object(context.get("platform_variables"))
+            else None
+        )
         self.session_id = context.get("session_id", None)
         if self.session_id is None:
             self.session_id = get_current_unix_timestamp()
@@ -96,4 +102,12 @@ class ContextModel:
         self.session_id = session_id
     
     def get_bucketing_seed(self) -> str:
-        return self.bucketingSeed
+        return self.bucketingSeed
+    
+    def get_platform_variables(self) -> Optional[Dict[str, Any]]:
+        return self.platform_variables
+
+    def set_platform_variables(self, platform_variables: Optional[Dict[str, Any]]) -> None:
+        self.platform_variables = (
+            dict(platform_variables) if is_object(platform_variables) else None
+        )

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/packages/segmentation_evaluator/core/segmentation_manager.py

@@ -24,6 +24,10 @@ from ....models.user.context_model import ContextModel
 from ....utils.gateway_service_util import get_query_params, get_from_gateway_service
 from ....constants.Constants import Constants
 from ....enums.api_enum import ApiEnum
+from ..utils.web_testing_segment_util import (
+    dsl_contains_campaign_variation_node,
+    is_web_testing_campaigns_absent_or_null,
+)
 
 
 class SegmentationManager:
@@ -81,14 +85,25 @@ class SegmentationManager:
 
         # Check if any holdout requires gateway service
         holdouts = settings.get_holdouts() or []
-        is_gateway_service_required_for_holdouts = len(list(filter(lambda holdout: holdout.get_is_gateway_service_required(), holdouts))) > 0
-        # Call gateway service if required for segmentation OR if gateway service is provided and user agent is available
+        is_gateway_service_required_for_holdouts = len(
+            list(
+                filter(
+                    lambda holdout: holdout.get_is_gateway_service_required(), holdouts
+                )
+            )
+        ) > 0
+        is_segmentation_gateway_required = (
+            feature.get_is_gateway_service_required()
+            or is_gateway_service_required_for_holdouts
+        )
+        # Call get-user-details only when gateway_service is configured and
+        # segmentation (feature or holdout) requires gateway data.
+        # proxy_url alone must never trigger a gateway call.
         should_call_gateway_service = (
-            (feature.get_is_gateway_service_required() and not SettingsManager.get_instance().is_on_platform_host()) or
-            (not SettingsManager.get_instance().is_on_platform_host() and
-             (context.get_user_agent() or context.get_ip_address()))
-        ) or is_gateway_service_required_for_holdouts
-        
+            SettingsManager.get_instance().is_gateway_service_provided
+            and is_segmentation_gateway_required
+        )
+
         if should_call_gateway_service and context.get_vwo() is None:
             query_params = {}
             if not context.get_user_agent() and not context.get_ip_address():
@@ -115,4 +130,11 @@ class SegmentationManager:
         :param properties: The properties to validate against.
         :return: True if segmentation is valid, otherwise False.
         """
+        # if the dsl contains a campaign variation node, then we need to check if the campaign variation is valid
+        if dsl_contains_campaign_variation_node(dsl):
+            evaluation_context = getattr(self.evaluator, "context", None)
+            if evaluation_context is None or is_web_testing_campaigns_absent_or_null(
+                evaluation_context
+            ):
+                return False
         return self.evaluator.is_segmentation_valid(dsl, properties)

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/packages/segmentation_evaluator/enums/segment_operator_value_enum.py

@@ -34,3 +34,4 @@ class SegmentOperatorValueEnum(Enum):
     IP = "ip_address"
     BROWSER_VERSION = "browser_version"
     OS_VERSION = "os_version"
+    WEB_CAMPAIGN_VARIATION = "campaignVariation"

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/packages/segmentation_evaluator/evaluators/segment_evaluator.py

@@ -68,6 +68,10 @@ class SegmentEvaluator:
             return SegmentOperandEvaluator().evaluate_string_operand_dsl(
                 sub_dsl, self.context, SegmentOperatorValueEnum.OS_VERSION.value
             )
+        elif operator == SegmentOperatorValueEnum.WEB_CAMPAIGN_VARIATION.value:
+            return SegmentOperandEvaluator().evaluate_campaign_variation_dsl(
+                sub_dsl, self.context
+            )
         else:
             return False
 

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/packages/segmentation_evaluator/evaluators/segment_operand_evaluator.py

@@ -16,6 +16,11 @@
 import re
 from typing import Dict, Any
 from ..utils.segment_util import get_key_value, match_with_regex
+from ..utils.web_testing_segment_util import (
+    coerce_campaign_variation_operand_to_str,
+    parse_web_testing_campaigns_from_context,
+    evaluate_web_testing_campaign_variation,
+)
 from ..enums.segment_operand_regex_enum import SegmentOperandRegexEnum
 from ..enums.segment_operand_value_enum import SegmentOperandValueEnum
 from ..enums.segment_operator_value_enum import SegmentOperatorValueEnum
@@ -84,6 +89,25 @@ class SegmentOperandEvaluator:
                 operand_type, processed_values["operand_value"], tag_value
             )
 
+    def evaluate_campaign_variation_dsl(
+        self, dsl_operand_value: Any, context: ContextModel
+    ) -> bool:
+        """
+        Evaluates a campaignVariation DSL operand against the user's web testing campaign assignments.
+
+        :param dsl_operand_value: The raw operand value from the DSL (e.g. "123_1", "!123", 100).
+        :param context: The context object containing platform_variables.web_testing_campaigns.
+        :return: True if the segment condition is satisfied, otherwise False.
+        """
+        operand_str = coerce_campaign_variation_operand_to_str(dsl_operand_value)
+        if operand_str is None:
+            return False
+
+        operand_str = operand_str.strip()
+        campaigns_map = parse_web_testing_campaigns_from_context(context)
+        result, _invalid = evaluate_web_testing_campaign_variation(operand_str, campaigns_map)
+        return result
+
     def evaluate_user_dsl(self, dsl_operand_value, properties):
         """
         Evaluates a user DSL expression to check if a user ID is in a specified List.

wingify_fme_python_sdk-1.61.0/wingify/packages/segmentation_evaluator/utils/web_testing_segment_util.py

@@ -0,0 +1,295 @@
+# Copyright 2024-2026 Wingify Software Pvt. Ltd.
+#
+# 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.
+
+import json
+import math
+import re
+from typing import Any, Dict, Optional, Tuple
+
+from ....models.user.context_model import ContextModel
+from ....utils.data_type_util import (
+    get_type,
+    is_array,
+    is_boolean,
+    is_defined,
+    is_null,
+    is_number,
+    is_object,
+    is_string,
+)
+from ...logger.core.log_manager import LogManager
+from ....enums.api_enum import ApiEnum
+from ..enums.segment_operator_value_enum import SegmentOperatorValueEnum
+
+_WEB_TESTING_JSON_STRING_KEY_REGEX = re.compile(r'"([^"\\]*)"\s*:')
+
+def coerce_campaign_variation_operand_to_str(operand: Any) -> Optional[str]:
+    """
+    Coerces a campaignVariation operand to a string when the value is a valid string or finite number.
+
+    :param operand: Raw campaignVariation operand from the segmentation DSL.
+    :return: Coerced operand string, or None if the type cannot be coerced.
+    """
+    if is_null(operand):
+        return None
+    if is_boolean(operand):
+        return None
+    if is_string(operand):
+        return operand
+    if is_number(operand):
+        # bool excluded above; avoids treating True as 1 via int subclassing.
+        if type(operand) is float:
+            if not math.isfinite(operand):
+                return None
+            if operand.is_integer():
+                return str(int(operand))
+            return str(operand)
+        return str(operand)
+    if is_array(operand) or is_object(operand):
+        return None
+    return None
+
+
+def normalize_web_testing_campaigns_map(web_testing_source: Dict) -> Dict[str, str]:
+    """
+    Normalizes a web_testing_campaigns map so campaign and variation IDs are non-empty string keys and values.
+
+    :param web_testing_source: Campaign ID to variation ID map from context or parsed JSON.
+    :return: Map with string campaign keys and string variation values.
+    """
+    normalized_campaigns_map: Dict[str, str] = {}
+    # iterate over the web testing source and normalize the campaign ids and variation ids
+    for campaign_key in web_testing_source:
+        variation_raw = web_testing_source[campaign_key]
+        # convert the campaign key to a string
+        campaign_key_as_str = str(campaign_key)
+        # if the variation raw is not None and the campaign key as string is not empty, then add the campaign key and variation to the normalized campaigns map
+        if is_defined(variation_raw) and len(campaign_key_as_str) > 0:
+            normalized_campaigns_map[campaign_key_as_str] = str(variation_raw)
+    return normalized_campaigns_map
+
+
+def _log_first_duplicate_json_object_key_scan(
+    web_testing_campaigns_json: str,
+    context: ContextModel,
+) -> None:
+    """
+    Scans a web_testing_campaigns JSON string for duplicate object keys and logs the first duplicate found.
+
+    :param web_testing_campaigns_json: Trimmed JSON string of web_testing_campaigns.
+    :param context: User context used for debug metadata in the error log.
+    :return: None; parsing continues after logging (last duplicate value wins).
+    """
+    # set to track the keys seen so far
+    keys_seen_so_far = set()
+    # iterate over the web testing campaigns json and log the first duplicate json object key
+    for key_regex_match in _WEB_TESTING_JSON_STRING_KEY_REGEX.finditer(
+        web_testing_campaigns_json
+    ):
+        object_key_name = key_regex_match.group(1)
+        # if the object key name is already in the keys seen so far, then log an error
+        if object_key_name in keys_seen_so_far:
+            LogManager.get_instance().error_log(
+                "INVALID_WEB_TESTING_CAMPAIGNS_DUPLICATE_KEY",
+                {"duplicateKey": object_key_name},
+                {
+                    "an": ApiEnum.GET_FLAG.value,
+                    "uuid": context.get_vwo_uuid(),
+                    "sId": context.get_session_id(),
+                },
+            )
+            return
+        # add the object key name to the keys seen so far
+        keys_seen_so_far.add(object_key_name)
+
+def is_web_testing_campaigns_absent_or_null(context: ContextModel) -> bool:
+    """
+    Returns whether platform_variables.web_testing_campaigns is missing or explicitly null.
+
+    :param context: User context that may carry platform_variables.
+    :return: True if web_testing_campaigns is absent or null; otherwise False.
+    """
+    # get the platform variables
+    platform_variables = context.get_platform_variables()
+    # if the platform variables are not present, then return True
+    if is_null(platform_variables) or not platform_variables:
+        return True
+    if not is_object(platform_variables):
+        return True
+    if "web_testing_campaigns" not in platform_variables:
+        return True
+    # get the web testing campaigns input
+    web_testing_campaigns_input = platform_variables.get("web_testing_campaigns")
+    # if the web testing campaigns input is None, then return True
+    if is_null(web_testing_campaigns_input):
+        return True
+    return False
+
+def dsl_contains_campaign_variation_node(segmentation_dsl: Any) -> bool:
+    """
+    Recursively checks whether a segmentation DSL tree contains a campaignVariation operator node.
+
+    :param segmentation_dsl: Segmentation DSL object to walk (and/or/not/campaignVariation nodes).
+    :return: True if any campaignVariation node exists in the tree; otherwise False.
+    """
+    # if the segmentation dsl is None or not a dictionary, then return False
+    if is_null(segmentation_dsl) or not is_object(segmentation_dsl):
+        return False
+
+    # iterate over the segmentation dsl and check if it contains a campaign variation node
+    for dsl_property_name in segmentation_dsl:
+        # if the dsl property name is the campaign variation node, then return True
+        if dsl_property_name == SegmentOperatorValueEnum.WEB_CAMPAIGN_VARIATION.value:
+            return True
+
+        nested_value = segmentation_dsl[dsl_property_name]
+        if is_array(nested_value):
+            for list_item in nested_value:
+                if dsl_contains_campaign_variation_node(list_item):
+                    return True
+        elif is_object(nested_value):
+            if dsl_contains_campaign_variation_node(nested_value):
+                return True
+
+    return False
+
+
+def parse_web_testing_campaigns_from_context(
+    context: ContextModel,
+) -> Optional[Dict[str, str]]:
+    """
+    Parses context.platform_variables.web_testing_campaigns from a dict or JSON string into a normalized map.
+
+    :param context: User context containing platform_variables.web_testing_campaigns.
+    :return: Normalized campaign-to-variation map, or None if missing, invalid, or unparseable.
+    """
+    platform_variables = context.get_platform_variables()
+    if is_null(platform_variables) or not platform_variables:
+        return None
+    if not is_object(platform_variables):
+        return None
+
+    web_testing_campaigns_raw = platform_variables.get("web_testing_campaigns")
+    if is_null(web_testing_campaigns_raw):
+        return None
+
+    # if the web testing campaigns raw is an object map, normalize it.
+    if is_object(web_testing_campaigns_raw):
+        return normalize_web_testing_campaigns_map(web_testing_campaigns_raw)
+
+    # if the web testing campaigns raw is a string, then parse the web testing campaigns
+    if is_string(web_testing_campaigns_raw):
+        trimmed_json_input = web_testing_campaigns_raw.strip()
+        if trimmed_json_input == "":
+            return None
+        _log_first_duplicate_json_object_key_scan(trimmed_json_input, context)
+        try:
+            # parse the web testing campaigns as a json object
+            parsed_json_object = json.loads(trimmed_json_input)
+            # if the parsed json object is an object map, normalize it
+            if is_object(parsed_json_object):
+                return normalize_web_testing_campaigns_map(parsed_json_object)
+            # if the parsed json object is not an object map, then log an error
+            LogManager.get_instance().error_log(
+                "INVALID_WEB_TESTING_CAMPAIGNS_JSON",
+                {},
+                {
+                    "an": ApiEnum.GET_FLAG.value,
+                    "uuid": context.get_vwo_uuid(),
+                    "sId": context.get_session_id(),
+                },
+            )
+        except json.JSONDecodeError:
+            # if the json decode error is raised, then log an error
+            LogManager.get_instance().error_log(
+                "INVALID_WEB_TESTING_CAMPAIGNS_JSON",
+                {},
+                {
+                    "an": ApiEnum.GET_FLAG.value,
+                    "uuid": context.get_vwo_uuid(),
+                    "sId": context.get_session_id(),
+                },
+            )
+        return None
+
+    # if the web testing campaigns raw is not an object or a string, then log an error
+    value_kind_label = get_type(web_testing_campaigns_raw)
+    LogManager.get_instance().error_log(
+        "INVALID_WEB_TESTING_CAMPAIGNS_TYPE",
+        {"kind": value_kind_label},
+        {
+            "an": ApiEnum.GET_FLAG.value,
+            "uuid": context.get_vwo_uuid(),
+            "sId": context.get_session_id(),
+        },
+    )
+    return None
+
+def evaluate_web_testing_campaign_variation(
+    operand_encoding: str,
+    campaigns_map: Optional[Dict[str, str]],
+) -> Tuple[bool, bool]:
+    """
+    Evaluates a campaignVariation operand encoding against the user's web testing campaign assignments.
+
+    :param operand_encoding: Encoded operand (e.g. "123", "123_2", "123_!2", "!123").
+    :param campaigns_map: Normalized map of campaign ID to assigned variation ID, or None.
+    :return: Tuple of (segment matched, operand encoding invalid).
+    """
+    if not is_string(operand_encoding):
+        return (False, True)
+
+    assignments_by_campaign_id = (
+        campaigns_map if is_defined(campaigns_map) else {}
+    )
+
+    # e.g. "!123" — not in campaign 123 (no assignment for that campaign id).
+    not_in_campaign_regex_match = re.match(r"^!(\d+)$", operand_encoding)
+    if not_in_campaign_regex_match:
+        campaign_id_digits = not_in_campaign_regex_match.group(1)
+        exists_in_assignments_map = campaign_id_digits in assignments_by_campaign_id
+        return (not exists_in_assignments_map, False)
+
+    # e.g. "123_!3" — in campaign 123 but assigned variation is not 3.
+    in_campaign_but_not_variation_regex_match = re.match(r"^(\d+)_!(\d+)$", operand_encoding)
+    # if the operand encoding is a campaign and variation id, then check if the user is in the campaign but not the variation
+    if in_campaign_but_not_variation_regex_match:
+        campaign_id_digits = in_campaign_but_not_variation_regex_match.group(1)
+        variation_id_digits = in_campaign_but_not_variation_regex_match.group(2)
+        # if the campaign id is not in the assignments by campaign id, then return False and False
+        if campaign_id_digits not in assignments_by_campaign_id:
+            return (False, False)
+        assigned_variation_id = assignments_by_campaign_id[campaign_id_digits]
+        return (assigned_variation_id != variation_id_digits, False)
+
+    # e.g. "123_3" — in campaign 123 with variation exactly 3.
+    campaign_and_variation_regex_match = re.match(r"^(\d+)_(\d+)$", operand_encoding)
+    if campaign_and_variation_regex_match:
+        # if the campaign id is not in the assignments by campaign id, then return False
+        campaign_id_digits = campaign_and_variation_regex_match.group(1)
+        # get the variation id digits
+        variation_id_digits = campaign_and_variation_regex_match.group(2)
+        if campaign_id_digits not in assignments_by_campaign_id:
+            return (False, False)
+        assigned_variation_id = assignments_by_campaign_id[campaign_id_digits]
+        return (assigned_variation_id == variation_id_digits, False)
+
+    # e.g. "123" — in campaign 123 (any assigned variation counts).
+    campaign_id_only_regex_match = re.match(r"^(\d+)$", operand_encoding)
+    if campaign_id_only_regex_match:
+        campaign_id_digits = campaign_id_only_regex_match.group(1)
+        user_in_campaign = campaign_id_digits in assignments_by_campaign_id
+        return (user_in_campaign, False)
+
+    return (False, True)

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/resources/error-messages.json

@@ -12,13 +12,15 @@
     "UPDATING_CLIENT_INSTANCE_FAILED_WHEN_WEBHOOK_TRIGGERED": "Failed to fetch settings. {brand} client instance couldn't be updated. API:{apiName} called having isViaWebhook:{isViaWebhook}. Error: {err}",
   
     "EXECUTION_FAILED": "API - {apiName} failed to execute. Error:{err}",
+    "INTEGRATIONS_CALLBACK_FAILED": "Error while executing integrations_callback: Error: {err}",
     "INVALID_PARAM": "Key:{key} passed to API:{apiName} is not of valid type. Got type:{type}, should be:{correctType}",
     "INVALID_CONTEXT_PASSED": "Context should be of type:object and must contain a mandatory key: id, which is User ID",
+    "INVALID_CONTEXT_USER_ID": "user_id under context must be a string value",
     "INVALID_BUCKETING_SEED": "Invalid bucketingSeed passed, since it can only be a valid string. Removing it from context so that userId is used for decisioning.",
   
     "FEATURE_NOT_FOUND": "Feature not found for the key:{featureKey}",
     "FEATURE_NOT_FOUND_WITH_ID": "Feature not found for the id:{featureId}",
-    "EVENT_NOT_FOUND": "Event:{eventName} not found in any of the features' metrics",
+    "EVENT_NOT_FOUND": "Event:{eventName} not found in any of the features' metrics, please ensure event API name is being used correctly",
   
     "ERROR_READING_STORED_DATA_IN_STORAGE": "Error reading data from storage. Error:{err}",
     "ERROR_STORING_DATA_IN_STORAGE": "Key:{featureKey} is not valid. Unable to store data into storage",
@@ -49,5 +51,12 @@
 
     "ERROR_SENDING_DEBUG_EVENT": "Error occurred while sending debugger event. Error:{err}",
     "ERROR_SETTING_ALIAS": "Error while setting alias on gateway service. Error: {err}",
-    "ERROR_GETTING_ALIAS": "Error while getting alias from gateway service. Error: {err}"
+    "ERROR_GETTING_ALIAS": "Error while getting alias from gateway service. Error: {err}",
+
+    "INVALID_WEB_TESTING_CAMPAIGNS_JSON": "webTestingCampaigns must be a JSON object (not an array)",
+    "INVALID_WEB_TESTING_CAMPAIGNS_DUPLICATE_KEY": "webTestingCampaigns JSON string contains duplicate object key: {duplicateKey}, only last occurrence is considered",
+    "INVALID_WEB_TESTING_CAMPAIGNS_TYPE": "webTestingCampaigns has invalid type: {kind}",
+    "INVALID_WEB_TESTING_CAMPAIGN_VARIATION_OPERAND_TYPE": "campaignVariation operand must be a string or finite number, got type: {type}",
+    "INVALID_WEB_TESTING_CAMPAIGN_VARIATION_OPERAND_EMPTY": "campaignVariation operand is empty",
+    "INVALID_WEB_TESTING_CAMPAIGN_VARIATION_OPERAND_FORMAT": "Invalid campaignVariation operand encoding: {operandEncoding}"
   }

{wingify_fme_python_sdk-1.55.0 → wingify_fme_python_sdk-1.61.0}/wingify/services/hooks_manager.py

@@ -14,6 +14,7 @@
 
 
 from typing import Callable, Dict, Any, Optional
+from ..packages.logger.core.log_manager import LogManager
 
 
 class HooksManager:
@@ -36,7 +37,15 @@ class HooksManager:
         :param properties: A dictionary of properties to pass to the callback.
         """
         if self.is_callback_function and self.callback:
-            self.callback(properties)
+            try:
+                self.callback(properties)
+            except Exception as err:
+                LogManager.get_instance().error_log(
+                    "INTEGRATIONS_CALLBACK_FAILED",
+                    data={"err": str(err)},
+                    debug_data={"an": properties.get("api")},
+                    should_send_log_to_vwo=False,
+                )
 
     def set(self, properties: Dict[str, Any]) -> None:
         """