feat: attribute based targeting

sakshamg1304 · rohitesh-wingify · commit 513c1ec6091d · 2025-09-04T12:45:29.000+05:30
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.13.0] - 2025-09-04
+
+### Added
+
+- Post-segmentation variables are now automatically included as unregistered attributes, enabling post-segmentation without requiring manual setup.
+- Added support for built-in targeting conditions, including browser version, OS version, and IP address, with advanced operator support (greaterThan, lessThan, regex).
+
 ## [1.12.0] - 2025-09-02
 
 ### Added
diff --git a/setup.py b/setup.py
@@ -121,7 +121,7 @@ def run(self):
 
 setup(
     name="vwo-fme-python-sdk",
-    version="1.12.0",
+    version="1.13.0",
     description="VWO Feature Management and Experimentation SDK for Python",
     long_description=long_description,
     long_description_content_type="text/markdown",
diff --git a/vwo/constants/Constants.py b/vwo/constants/Constants.py
@@ -17,7 +17,7 @@ class Constants:
     # TODO: read from setup.py
     sdk_meta = {
         "name": "vwo-fme-python-sdk",
-        "version": "1.12.0"
+        "version": "1.13.0"
     }
 
     # Constants
diff --git a/vwo/models/user/context_model.py b/vwo/models/user/context_model.py
@@ -14,7 +14,7 @@
 
 
 from .context_vwo_model import ContextVWOModel
-from typing import Dict
+from typing import Dict, List
 
 
 class ContextModel:
@@ -27,6 +27,7 @@ def __init__(self, context: Dict):
             "variation_targeting_variables", {}
         )
         self._vwo = ContextVWOModel(context.get("_vwo")) if "_vwo" in context else None
+        self.post_segmentation_variables = context.get("post_segmentation_variables", [])
 
     def get_id(self) -> str:
         return str(self.id) if self.id is not None else None
@@ -56,3 +57,9 @@ def get_vwo(self) -> ContextVWOModel:
 
     def set_vwo(self, vwo: ContextVWOModel) -> None:
         self._vwo = vwo
+
+    def get_post_segmentation_variables(self) -> List[str]:
+        return self.post_segmentation_variables
+
+    def set_post_segmentation_variables(self, post_segmentation_variables: List[str]) -> None:
+        self.post_segmentation_variables = post_segmentation_variables
diff --git a/vwo/packages/segmentation_evaluator/core/segmentation_manager.py b/vwo/packages/segmentation_evaluator/core/segmentation_manager.py
@@ -22,6 +22,8 @@
 from ....models.campaign.feature_model import FeatureModel
 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 ....services.url_service import UrlService
 
 
 class SegmentationManager:
@@ -77,27 +79,32 @@ def set_contextual_data(
         if not context.get_user_agent() and not context.get_ip_address():
             return
 
-        if (
-            feature.get_is_gateway_service_required()
-        ):  # Check if gateway service is required
-            if SettingsManager.get_instance().is_gateway_service_provided and (
-                context.get_vwo() is None
-            ):
-                query_params = {}
-                if context.get_user_agent():
-                    query_params["userAgent"] = context.get_user_agent()
-
-                if context.get_ip_address():
-                    query_params["ipAddress"] = context.get_ip_address()
-
-                try:
-                    params = get_query_params(query_params)
-                    _vwo = get_from_gateway_service(params, UrlEnum.GET_USER_DATA.value)
-                    context.set_vwo(ContextVWOModel(_vwo))
-                except Exception as err:
-                    LogManager.get_instance().error(
-                        f"Error in setting contextual data for segmentation. Got error: {err}"
-                    )
+        # Call gateway service if required for segmentation OR if gateway service is provided and user agent is available
+        should_call_gateway_service = (
+            (feature.get_is_gateway_service_required() and Constants.HOST_NAME not in UrlService.get_base_url()) or
+            (Constants.HOST_NAME not in UrlService.get_base_url() and 
+             (context.get_user_agent() or context.get_ip_address()))
+        )
+        
+        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():
+                return
+                
+            if context.get_user_agent():
+                query_params["userAgent"] = context.get_user_agent()
+
+            if context.get_ip_address():
+                query_params["ipAddress"] = context.get_ip_address()
+
+            try:
+                params = get_query_params(query_params)
+                _vwo = get_from_gateway_service(params, UrlEnum.GET_USER_DATA.value)
+                context.set_vwo(ContextVWOModel(_vwo))
+            except Exception as err:
+                LogManager.get_instance().error(
+                    f"Error in setting contextual data for segmentation. Got error: {err}"
+                )
 
     def validate_segmentation(self, dsl, properties):
         """
diff --git a/vwo/packages/segmentation_evaluator/enums/segment_operand_regex_enum.py b/vwo/packages/segmentation_evaluator/enums/segment_operand_regex_enum.py
@@ -25,7 +25,7 @@ class SegmentOperandRegexEnum(Enum):
     REGEX_MATCH = r"^regex\((.*)\)"
     STARTING_STAR = r"^\*"
     ENDING_STAR = r"\*$"
-    GREATER_THAN_MATCH = r"^gt\((\d+\.?\d*|\.\d+)\)$"
-    GREATER_THAN_EQUAL_TO_MATCH = r"^gte\((\d+\.?\d*|\.\d+)\)$"
-    LESS_THAN_MATCH = r"^lt\((\d+\.?\d*|\.\d+)\)$"
-    LESS_THAN_EQUAL_TO_MATCH = r"^lte\((\d+\.?\d*|\.\d+)\)$"
+    GREATER_THAN_MATCH = r"^gt\(([\d.]+)\)$"
+    GREATER_THAN_EQUAL_TO_MATCH = r"^gte\(([\d.]+)\)$"
+    LESS_THAN_MATCH = r"^lt\(([\d.]+)\)$"
+    LESS_THAN_EQUAL_TO_MATCH = r"^lte\(([\d.]+)\)$"
diff --git a/vwo/packages/segmentation_evaluator/enums/segment_operator_value_enum.py b/vwo/packages/segmentation_evaluator/enums/segment_operator_value_enum.py
@@ -31,3 +31,6 @@ class SegmentOperatorValueEnum(Enum):
     BROWSER_AGENT = "browser_string"
     UA = "ua"
     FEATURE_ID = "featureId"
+    IP = "ip_address"
+    BROWSER_VERSION = "browser_version"
+    OS_VERSION = "os_version"
diff --git a/vwo/packages/segmentation_evaluator/evaluators/segment_evaluator.py b/vwo/packages/segmentation_evaluator/evaluators/segment_evaluator.py
@@ -55,6 +55,18 @@ def is_segmentation_valid(self, dsl, properties):
             return SegmentOperandEvaluator().evaluate_user_agent_dsl(
                 sub_dsl, self.context
             )
+        elif operator == SegmentOperatorValueEnum.IP.value:
+            return SegmentOperandEvaluator().evaluate_string_operand_dsl(
+                sub_dsl, self.context, SegmentOperatorValueEnum.IP.value
+            )
+        elif operator == SegmentOperatorValueEnum.BROWSER_VERSION.value:
+            return SegmentOperandEvaluator().evaluate_string_operand_dsl(
+                sub_dsl, self.context, SegmentOperatorValueEnum.BROWSER_VERSION.value
+            )
+        elif operator == SegmentOperatorValueEnum.OS_VERSION.value:
+            return SegmentOperandEvaluator().evaluate_string_operand_dsl(
+                sub_dsl, self.context, SegmentOperatorValueEnum.OS_VERSION.value
+            )
         else:
             return False
 
diff --git a/vwo/packages/segmentation_evaluator/evaluators/segment_operand_evaluator.py b/vwo/packages/segmentation_evaluator/evaluators/segment_operand_evaluator.py
@@ -18,6 +18,7 @@
 from ..utils.segment_util import get_key_value, match_with_regex
 from ..enums.segment_operand_regex_enum import SegmentOperandRegexEnum
 from ..enums.segment_operand_value_enum import SegmentOperandValueEnum
+from ..enums.segment_operator_value_enum import SegmentOperatorValueEnum
 from ...logger.core.log_manager import LogManager
 from ....utils.gateway_service_util import get_from_gateway_service
 from ....enums.url_enum import UrlEnum
@@ -244,48 +245,42 @@ def extract_result(self, operand_type: str, operand_value: str, tag_value: str):
         :param tag_value: The value of the tag to compare against.
         :return: The result of the evaluation.
         """
+        result = False
+
         if tag_value is None:
             return False
 
         # Ensure operand_value and tag_value are strings
-        operand_value = str(operand_value)
-        tag_value = str(tag_value)
+        operand_value_str = str(operand_value)
+        tag_value_str = str(tag_value)
+
         if operand_type == SegmentOperandValueEnum.LOWER_VALUE.value:
-            return operand_value.lower() == tag_value.lower()
+            result = operand_value_str.lower() == tag_value_str.lower()
         elif operand_type == SegmentOperandValueEnum.STARTING_ENDING_STAR_VALUE.value:
-            return operand_value in tag_value
+            result = tag_value_str.find(operand_value_str) != -1
         elif operand_type == SegmentOperandValueEnum.STARTING_STAR_VALUE.value:
-            return tag_value.endswith(operand_value)
+            result = tag_value_str.endswith(operand_value_str)
         elif operand_type == SegmentOperandValueEnum.ENDING_STAR_VALUE.value:
-            return tag_value.startswith(operand_value)
+            result = tag_value_str.startswith(operand_value_str)
         elif operand_type == SegmentOperandValueEnum.REGEX_VALUE.value:
             try:
-                pattern = re.compile(operand_value)
-                return bool(pattern.search(tag_value))
+                pattern = re.compile(operand_value_str)
+                matcher = pattern.search(tag_value_str)
+                result = matcher is not None
             except re.error:
-                return False
+                result = False
         elif operand_type == SegmentOperandValueEnum.GREATER_THAN_VALUE.value:
-            try:
-                return float(tag_value) > float(operand_value)
-            except ValueError:
-                return False
+            result = self.compare_versions(tag_value_str, operand_value_str) > 0
         elif operand_type == SegmentOperandValueEnum.GREATER_THAN_EQUAL_TO_VALUE.value:
-            try:
-                return float(tag_value) >= float(operand_value)
-            except ValueError:
-                return False
+            result = self.compare_versions(tag_value_str, operand_value_str) >= 0
         elif operand_type == SegmentOperandValueEnum.LESS_THAN_VALUE.value:
-            try:
-                return float(tag_value) < float(operand_value)
-            except ValueError:
-                return False
+            result = self.compare_versions(tag_value_str, operand_value_str) < 0
         elif operand_type == SegmentOperandValueEnum.LESS_THAN_EQUAL_TO_VALUE.value:
-            try:
-                return float(tag_value) <= float(operand_value)
-            except ValueError:
-                return False
+            result = self.compare_versions(tag_value_str, operand_value_str) <= 0
         else:
-            return tag_value == operand_value
+            result = tag_value_str == operand_value_str
+
+        return result
 
     def convert_value(self, value):
         # Check if the value is a boolean
@@ -303,3 +298,121 @@ def convert_value(self, value):
         except ValueError:
             # Return the value as is if it's not a number
             return value
+
+    def evaluate_string_operand_dsl(self, dsl_operand_value, context: ContextModel, operand_type: SegmentOperatorValueEnum):
+        """
+        Evaluates a given string tag value against a DSL operand value.
+
+        :param dsl_operand_value: The DSL operand string (e.g., "contains(\"value\")").
+        :param context: The context object containing the value to evaluate.
+        :param operand_type: The type of operand being evaluated (ip_address, browser_version, os_version).
+        :return: True if tag value matches DSL operand criteria, false otherwise.
+        """
+        operand = str(dsl_operand_value)
+
+        # Determine the tag value based on operand type
+        tag_value = self.get_tag_value_for_operand_type(context, operand_type)
+
+
+        if tag_value is None:
+            self.log_missing_context_error(operand_type)
+            return False
+        
+        operand_type_and_value = self.pre_process_operand_value(operand)
+        processed_values = self.process_values(operand_type_and_value["operand_value"], tag_value)
+        tag_value = processed_values["tag_value"]
+
+        return self.extract_result(
+            operand_type_and_value["operand_type"], 
+            processed_values["operand_value"].strip().replace('"', ''), 
+            tag_value
+        )
+
+    def get_tag_value_for_operand_type(self, context: ContextModel, operand_type: SegmentOperatorValueEnum):
+        """
+        Gets the appropriate tag value based on the operand type.
+
+        :param context: The context object.
+        :param operand_type: The type of operand.
+        :return: The tag value or None if not available.
+        """
+        if operand_type == SegmentOperatorValueEnum.IP.value:
+            return context.get_ip_address()
+        elif operand_type == SegmentOperatorValueEnum.BROWSER_VERSION.value:
+            return self.get_browser_version_from_context(context)
+        else:
+            # Default works for OS version
+            return self.get_os_version_from_context(context)
+
+    def get_browser_version_from_context(self, context: ContextModel):
+        """
+        Gets browser version from context.
+
+        :param context: The context object.
+        :return: The browser version or None if not available.
+        """
+        if context.get_vwo() is None or context.get_vwo().get_ua_info() is None or len(context.get_vwo().get_ua_info()) == 0:
+            return None
+        
+        user_agent = context.get_vwo().get_ua_info()
+        
+        # Assuming UserAgent dictionary contains browser_version
+        if "browser_version" in user_agent:
+            return str(user_agent["browser_version"]) if user_agent["browser_version"] is not None else None
+        return None
+
+    def get_os_version_from_context(self, context: ContextModel):
+        """
+        Gets OS version from context.
+
+        :param context: The context object.
+        :return: The OS version or None if not available.
+        """
+        if context.get_vwo() is None or context.get_vwo().get_ua_info() is None or len(context.get_vwo().get_ua_info()) == 0:
+            return None
+        
+        user_agent = context.get_vwo().get_ua_info()
+        # Assuming UserAgent dictionary contains os_version
+        if "os_version" in user_agent:
+            return str(user_agent["os_version"]) if user_agent["os_version"] is not None else None
+        return None
+
+    def log_missing_context_error(self, operand_type: SegmentOperatorValueEnum):
+        """
+        Logs appropriate error message for missing context.
+
+        :param operand_type: The type of operand.
+        """
+        if operand_type == SegmentOperatorValueEnum.IP.value:
+            LogManager.get_instance().info("To evaluate IP segmentation, please provide ipAddress in context")
+        elif operand_type == SegmentOperatorValueEnum.BROWSER_VERSION.value:
+            LogManager.get_instance().info("To evaluate browser version segmentation, please provide userAgent in context")
+        else:
+            LogManager.get_instance().info("To evaluate OS version segmentation, please provide userAgent in context")
+
+    def compare_versions(self, version1: str, version2: str):
+        """
+        Compares two version strings using semantic versioning rules.
+        Supports formats like "1.2.3", "1.0", "2.1.4.5", etc.
+
+        :param version1: First version string
+        :param version2: Second version string
+        :return: -1 if version1 < version2, 0 if equal, 1 if version1 > version2
+        """
+        # Split versions by dots and convert to integers
+        parts1 = [int(part) if part.isdigit() else 0 for part in version1.split('.')]
+        parts2 = [int(part) if part.isdigit() else 0 for part in version2.split('.')]
+
+        # Find the maximum length to handle different version formats
+        max_length = max(len(parts1), len(parts2))
+
+        for i in range(max_length):
+            part1 = parts1[i] if i < len(parts1) else 0
+            part2 = parts2[i] if i < len(parts2) else 0
+
+            if part1 < part2:
+                return -1
+            elif part1 > part2:
+                return 1
+        
+        return 0  # Versions are equal
diff --git a/vwo/utils/gateway_service_util.py b/vwo/utils/gateway_service_util.py
@@ -67,7 +67,7 @@ def get_query_params(query_params: Dict[str, Any]) -> Dict[str, str]:
 def add_is_gateway_service_required_flag(settings: SettingsModel) -> None:
     # Regex pattern to match the specified fields
     main_pattern = re.compile(
-        r"\b(country|region|city|os|device_type|browser_string|ua)\b", re.IGNORECASE
+        r"\b(country|region|city|os|device_type|browser_string|ua|os_version|browser_version)\b", re.IGNORECASE
     )
     # Regex pattern to match inlist(...) under custom_variable
     custom_variable_pattern = re.compile(r"inlist\([^)]*\)", re.IGNORECASE)
diff --git a/vwo/utils/impression_util.py b/vwo/utils/impression_util.py
@@ -37,12 +37,10 @@ def create_and_send_impression_for_variation_shown(
     # Construct payload data for tracking the user
     payload = get_track_user_payload_data(
         settings,
-        context.get_id(),
         EventEnum.VWO_VARIATION_SHOWN.value,
         campaign_id,
         variation_id,
-        visitor_user_agent=context.get_user_agent(),
-        ip_address=context.get_ip_address(),
+        context,
     )
 
     vwo_instance = VWOClient.get_instance()
diff --git a/vwo/utils/network_util.py b/vwo/utils/network_util.py

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ class Constants:`
`17`	`17`	`# TODO: read from setup.py`
`18`	`18`	`sdk_meta = {`
`19`	`19`	`"name": "vwo-fme-python-sdk",`
`20`		`- "version": "1.12.0"`
	`20`	`+ "version": "1.13.0"`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`# Constants`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ def get_query_params(query_params: Dict[str, Any]) -> Dict[str, str]:`
`67`	`67`	`def add_is_gateway_service_required_flag(settings: SettingsModel) -> None:`
`68`	`68`	`# Regex pattern to match the specified fields`
`69`	`69`	`main_pattern = re.compile(`
`70`		`- r"\b(country\|region\|city\|os\|device_type\|browser_string\|ua)\b", re.IGNORECASE`
	`70`	`+ r"\b(country\|region\|city\|os\|device_type\|browser_string\|ua\|os_version\|browser_version)\b", re.IGNORECASE`
`71`	`71`	`)`
`72`	`72`	`# Regex pattern to match inlist(...) under custom_variable`
`73`	`73`	`custom_variable_pattern = re.compile(r"inlist\([^)]*\)", re.IGNORECASE)`