feat: support for multiple attributes in setAttribute call

Author: Abhi591

CHANGELOG.md

@@ -4,6 +4,12 @@ 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.6.0] - 2025-04-04
+
+### Added
+
+- Added support for sending multiple attributes at once using `set_attribute` method by passing a dictionary of key-value pairs to update user attributes in a single API call.
+
 ## [1.5.0] - 2025-03-12
 
 ### Added
@@ -120,4 +126,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   }
 
   vwo_client = init(options)
-  ```
+  ```

setup.py

@@ -121,7 +121,7 @@ def run(self):
 
 setup(
     name="vwo-fme-python-sdk",
-    version="1.5.0",
+    version="1.6.0",
     description="VWO Feature Management and Experimentation SDK for Python",
     long_description=long_description,
     long_description_content_type="text/markdown",

vwo/api/set_attribute_api.py

@@ -19,36 +19,37 @@
 from typing import Dict, Any
 from ..models.settings.settings_model import SettingsModel
 from ..models.user.context_model import ContextModel
-from ..utils.network_util import get_events_base_properties, get_attribute_payload_data, send_post_api_request
+from ..utils.network_util import (
+    get_events_base_properties,
+    get_attribute_payload_data,
+    send_post_api_request,
+)
 from ..enums.event_enum import EventEnum
 
+
 class SetAttributeApi:
-    def set_attribute(self, settings: SettingsModel, attribute_key: str, attribute_value: Any, context: ContextModel):
-        self.create_and_send_impression_for_attribute(settings, attribute_key, attribute_value, context)
-    
+    def set_attribute(
+        self, settings: SettingsModel, attribute_map: Dict, context: ContextModel
+    ):
+        self.create_and_send_impression_for_attribute(settings, attribute_map, context)
+
     def create_and_send_impression_for_attribute(
-        self,
-        settings: SettingsModel,
-        attribute_key: str,
-        attribute_value: Any, 
-        context: ContextModel
+        self, settings: SettingsModel, attribute_map: Dict, context: ContextModel
     ):
         properties = get_events_base_properties(
             EventEnum.VWO_SYNC_VISITOR_PROP.value,
             visitor_user_agent=context.get_user_agent(),
-            ip_address=context.get_ip_address()
+            ip_address=context.get_ip_address(),
         )
         # Construct payload data for tracking the goal
         payload = get_attribute_payload_data(
             settings,
             context.get_id(),
             EventEnum.VWO_SYNC_VISITOR_PROP.value,
-            attribute_key,
-            attribute_value,
+            attribute_map,
             visitor_user_agent=context.get_user_agent(),
-            ip_address=context.get_ip_address()
+            ip_address=context.get_ip_address(),
         )
 
         # Send the constructed properties and payload as a POST request
         send_post_api_request(properties, payload)
-            

vwo/constants/Constants.py

@@ -17,7 +17,7 @@ class Constants:
     # Mock package_file equivalent
     package_file = {
         "name": "vwo-fme-python-sdk",  # Replace with actual package name
-        "version": "1.5.0",  # Replace with actual package version
+        "version": "1.6.0",  # Replace with actual package version
     }
 
     # Constants

vwo/utils/network_util.py

@@ -30,6 +30,11 @@
 from ..enums.headers_enum import HeadersEnum
 import asyncio
 import threading
+from ..utils.function_util import (
+    get_current_unix_timestamp,
+    get_current_unix_timestamp_in_millis,
+    get_random_number,
+)
 
 def get_settings_path(sdk_key: str, account_id: str) -> Dict[str, Any]:
     path = {
@@ -181,23 +186,26 @@ def get_attribute_payload_data(
     settings: SettingsModel,
     user_id: str,
     event_name: str,
-    attribute_key: str,
-    attribute_value: Any,
-    visitor_user_agent: str = '',
-    ip_address: str = ''
+    attribute_map: Dict,
+    visitor_user_agent: str = "",
+    ip_address: str = "",
 ) -> Dict[str, Any]:
-    properties = _get_event_base_payload(settings, user_id, event_name, visitor_user_agent, ip_address)
-    
-    properties['d']['event']['props']['isCustomEvent'] = True
-    properties['d']['event']['props'][Constants.VWO_FS_ENVIRONMENT] = settings.get_sdk_key()
-    properties['d']['visitor']['props'][attribute_key] = attribute_value
-    
-    LogManager.get_instance().debug(debug_messages.get('IMPRESSION_FOR_SYNC_VISITOR_PROP').format(
-        eventName = event_name,
-        accountId = settings.get_account_id(),
-        userId = user_id
-    ))
-    
+    properties = _get_event_base_payload(
+        settings, user_id, event_name, visitor_user_agent, ip_address
+    )
+
+    properties["d"]["event"]["props"]["isCustomEvent"] = True
+    properties["d"]["event"]["props"][
+        Constants.VWO_FS_ENVIRONMENT
+    ] = settings.get_sdk_key()
+    properties["d"]["visitor"]["props"].update(attribute_map)
+
+    LogManager.get_instance().debug(
+        debug_messages.get("IMPRESSION_FOR_SYNC_VISITOR_PROP").format(
+            eventName=event_name, accountId=settings.get_account_id(), userId=user_id
+        )
+    )
+
     return properties
 
 

vwo/vwo_client.py

@@ -200,51 +200,99 @@ def track_event(
             )
             return {event_name: False}
 
-    def set_attribute(self, attribute_key: str, attribute_value: Any, context: Dict):
+    def set_attribute(
+        self, key_or_map: Any, value_or_context: Any, context: Dict = None
+    ):
         """
         Sets an attribute for a user in the context provided.
-        This method validates the types of the inputs before proceeding with the API call.
+        This method can be called in two ways:
+        1. set_attribute(key, value, context) - Sets a single attribute
+        2. set_attribute(attribute_map, context) - Sets multiple attributes
 
-        :param attribute_key: The key of the attribute to set.
-        :param attribute_value: The value of the attribute to set.
-        :param context: The context in which the attribute is being set.
+        The attribute values must be either strings, integers, or booleans.
+
+        :param key_or_map: Either the attribute key (str) or a map of attributes (Dict)
+        :param value_or_context: Either the attribute value or the context (if key_or_map is a Dict)
+        :param context: The context in which the attribute is being set (only used when setting single attribute)
         """
         api_name = "set_attribute"
 
         try:
-
             LogManager.get_instance().debug(
                 debug_messages.get("API_CALLED").format(apiName=api_name)
             )
 
-            # Validate featureKey is a string
-            if not is_string(attribute_key):
-                LogManager.get_instance().error(
-                    error_messages.get("API_INVALID_PARAM").format(
-                        apiName=api_name,
-                        key="attribute_key",
-                        type=type(attribute_key).__name__,
-                        correctType="string",
+            # Determine which calling pattern is being used
+            if context is not None:
+                # Single attribute pattern: (key, value, context)
+                if not is_string(key_or_map):
+                    LogManager.get_instance().error(
+                        error_messages.get("API_INVALID_PARAM").format(
+                            apiName=api_name,
+                            key="key",
+                            type=type(key_or_map).__name__,
+                            correctType="string",
+                        )
+                    )
+                    raise TypeError("TypeError: key should be a string")
+
+                if not isinstance(value_or_context, (str, int, bool, float)):
+                    LogManager.get_instance().error(
+                        error_messages.get("API_INVALID_PARAM").format(
+                            apiName=api_name,
+                            key="value",
+                            type=type(value_or_context).__name__,
+                            correctType="string, integer, float, or boolean",
+                        )
+                    )
+                    raise TypeError(
+                        "TypeError: value should be a string, integer, float, or boolean"
                     )
-                )
-                raise TypeError("TypeError: attribute_key should be a string")
 
-            if (
-                not is_string(attribute_value)
-                and not isinstance(attribute_value, int)
-                and not isinstance(attribute_value, bool)
-            ):
-                LogManager.get_instance().error(
-                    error_messages.get("API_INVALID_PARAM").format(
-                        apiName=api_name,
-                        key="attribute_value",
-                        type=type(attribute_value).__name__,
-                        correctType="string or int or bool",
+                attribute_map = {key_or_map: value_or_context}
+                user_context = context
+            else:
+                # Multiple attributes pattern: (attribute_map, context)
+                if not is_object(key_or_map) or not key_or_map:
+                    LogManager.get_instance().error(
+                        error_messages.get("API_INVALID_PARAM").format(
+                            apiName=api_name,
+                            key="attribute_map",
+                            type=type(key_or_map).__name__,
+                            correctType="object",
+                        )
+                    )
+                    raise TypeError(
+                        "TypeError: attribute_map should be a non-empty object"
                     )
-                )
-                raise TypeError(
-                    "TypeError: attribute_value should be an string or int or bool"
-                )
+
+                # Validate all keys and values in the attribute map
+                for key, value in key_or_map.items():
+                    if not is_string(key):
+                        LogManager.get_instance().error(
+                            error_messages.get("API_INVALID_PARAM").format(
+                                apiName=api_name,
+                                key="key",
+                                type=type(key).__name__,
+                                correctType="string",
+                            )
+                        )
+                        raise TypeError("TypeError: key should be a string")
+                    if not isinstance(value, (str, int, bool, float)):
+                        LogManager.get_instance().error(
+                            error_messages.get("API_INVALID_PARAM").format(
+                                apiName=api_name,
+                                key=f"value for key '{key}'",
+                                type=type(value).__name__,
+                                correctType="string, integer, float, or boolean",
+                            )
+                        )
+                        raise TypeError(
+                            f"TypeError: value for key '{key}' should be a string, integer, float or boolean"
+                        )
+
+                attribute_map = key_or_map
+                user_context = value_or_context
 
             # Validate settings are loaded and valid
             if not SettingsManager.is_settings_valid(self.original_settings):
@@ -253,19 +301,17 @@ def set_attribute(self, attribute_key: str, attribute_value: Any, context: Dict)
                 )
                 raise ValueError("Invalid Settings")
 
-            # Validate user ID is present in context
-            if not context or "id" not in context:
+            if not user_context or "id" not in user_context:
                 LogManager.get_instance().error(
                     error_messages.get("API_CONTEXT_INVALID")
                 )
                 raise ValueError("Invalid context")
 
-            context_model = ContextModel(context)
+            context_model = ContextModel(user_context)
 
-            # Fetch the feature flag value using FlagApi
             set_attribute_api = SetAttributeApi()
             set_attribute_api.set_attribute(
-                self._settings, attribute_key, attribute_value, context_model
+                self._settings, attribute_map, context_model
             )
             return