fix: Update FlagResult class and fix assignment tracking issue (#37)

Author: tyiuhc

src/amplitude_experiment/assignment/assignment.py

@@ -12,13 +12,14 @@ class Assignment:
     def __init__(self, user: User, results: Dict[str, FlagResult]):
         self.user = user
         self.results = results
-        self.timestamp = time.time()
+        self.timestamp = time.time() * 1000
 
     def canonicalize(self) -> str:
-        user = self.user.user_id.strip() if self.user.user_id else 'undefined'
-        device = self.user.device_id.strip() if self.user.device_id else 'undefined'
+        user = self.user.user_id.strip() if self.user.user_id else 'None'
+        device = self.user.device_id.strip() if self.user.device_id else 'None'
         canonical = user + ' ' + device + ' '
         for key in sorted(self.results):
-            value = self.results[key].value.strip() if self.results[key] else 'undefined'
+            value = self.results[key].variant['key'].strip() if self.results[key] and self.results[key].variant and \
+                                                                self.results[key].variant.get('key') else 'None'
             canonical += key.strip() + ' ' + value + ' '
         return canonical

src/amplitude_experiment/assignment/assignment_config.py

@@ -2,7 +2,6 @@
 
 
 class AssignmentConfig(amplitude.Config):
-    def __init__(self, api_key: str, cache_capacity: int = 65536, **kw):
-        self.api_key = api_key
-        self.cache_capacity = cache_capacity
+    def __init__(self, cache_capacity: int = 65536, **kw):
         super(AssignmentConfig, self).__init__(**kw)
+        self.cache_capacity = cache_capacity

src/amplitude_experiment/assignment/assignment_service.py

@@ -2,6 +2,7 @@
 from ..assignment.assignment import Assignment
 from ..assignment.assignment import DAY_MILLIS
 from ..assignment.assignment_filter import AssignmentFilter
+from ..util import hash_code
 
 FLAG_TYPE_MUTUAL_EXCLUSION_GROUP = "mutual-exclusion-group"
 FLAG_TYPE_HOLDOUT_GROUP = "holdout-group"
@@ -11,7 +12,7 @@ def to_event(assignment: Assignment) -> BaseEvent:
     event = BaseEvent(event_type='[Experiment] Assignment', user_id=assignment.user.user_id,
                       device_id=assignment.user.device_id, event_properties={}, user_properties={})
     for key in sorted(assignment.results):
-        event.event_properties[key + '.variant'] = assignment.results[key].value
+        event.event_properties[key + '.variant'] = assignment.results[key].variant['key']
 
     set_props = {}
     unset_props = {}
@@ -22,12 +23,12 @@ def to_event(assignment: Assignment) -> BaseEvent:
         elif assignment.results[key].is_default_variant:
             unset_props[f'[Experiment] {key}'] = '-'
         else:
-            set_props[f'[Experiment] {key}'] = assignment.results[key].value
+            set_props[f'[Experiment] {key}'] = assignment.results[key].variant['key']
 
     event.user_properties['$set'] = set_props
     event.user_properties['$unset'] = unset_props
 
-    event.insert_id = f'{event.user_id} {event.device_id} {hash(assignment.canonicalize())} {assignment.timestamp / DAY_MILLIS}'
+    event.insert_id = f'{event.user_id} {event.device_id} {hash_code(assignment.canonicalize())} {int(assignment.timestamp / DAY_MILLIS)}'
 
     return event
 

src/amplitude_experiment/flagresult.py

@@ -1,9 +1,8 @@
 class FlagResult:
-    def __init__(self, value: str, is_default_variant: bool, payload: str = None, exp_key: str = None,
-                 deployed: bool = None, type: str = None):
-        self.value = value
-        self.payload = payload
-        self.is_default_variant = is_default_variant
-        self.exp_key = exp_key
-        self.deployed = deployed
-        self.type = type
+    def __init__(self, result):
+        self.variant = result.get('variant')
+        self.description = result.get('description')
+        self.is_default_variant = result.get('isDefaultVariant')
+        self.exp_key = result.get('exp_key')
+        self.deployed = result.get('deployed')
+        self.type = result.get('type')

src/amplitude_experiment/local/client.py

@@ -6,6 +6,7 @@
 from amplitude import Amplitude
 
 from .config import LocalEvaluationConfig
+from ..flagresult import FlagResult
 from ..assignment import Assignment, AssignmentFilter, AssignmentService
 from ..assignment.assignment_service import FLAG_TYPE_MUTUAL_EXCLUSION_GROUP, FLAG_TYPE_HOLDOUT_GROUP
 from ..user import User
@@ -84,8 +85,7 @@ def evaluate(self, user: User, flag_keys: List[str] = None) -> Dict[str, Variant
                 variants[key] = Variant(value['variant'].get('key'), value['variant'].get('payload'))
             if included or evaluation_result[key]['type'] == FLAG_TYPE_MUTUAL_EXCLUSION_GROUP or \
                     evaluation_result[key]['type'] == FLAG_TYPE_HOLDOUT_GROUP:
-                assignment_result[key] = evaluation_result[key]
-
+                assignment_result[key] = FlagResult(value)
         if self.assignment_service:
             self.assignment_service.track(Assignment(user, assignment_result))
         return variants

src/amplitude_experiment/util/__init__.py

@@ -1 +1,2 @@
 from .cache import Cache
+from .hash_code import hash_code

src/amplitude_experiment/util/cache.py

@@ -1,5 +1,6 @@
 import time
 
+
 class Cache:
     class Node:
         def __init__(self, key, value):
@@ -64,4 +65,3 @@ def put(self, key, value):
             new_node = self.Node(key, value)
             self._add_node(new_node)
             self.cache[key] = new_node
-

src/amplitude_experiment/util/hash_code.py

@@ -0,0 +1,9 @@
+def hash_code(string) -> int:
+    hash_value = 0
+    if len(string) == 0:
+        return hash_value
+    for char in string:
+        chr_code = ord(char)
+        hash_value = ((hash_value << 5) - hash_value) + chr_code
+        hash_value &= 0xFFFFFFFF
+    return hash_value

tests/local/assignment/assignment_filter_test.py

@@ -10,8 +10,8 @@ def test_single_assignment(self):
         assignment_filter = AssignmentFilter(100)
         user = User(user_id='user', device_id='device')
         results = {}
-        result1 = FlagResult(value='on', is_default_variant=False)
-        result2 = FlagResult(value='control', is_default_variant=True)
+        result1 = FlagResult({'variant': {'key': 'on'}, 'isDefaultVariant': False})
+        result2 = FlagResult({'variant': {'key': 'control'}, 'isDefaultVariant': True})
         results['flag-key-1'] = result1
         results['flag-key-2'] = result2
         assignment = Assignment(user, results)
@@ -21,8 +21,8 @@ def test_duplicate_assignments(self):
         assignment_filter = AssignmentFilter(100)
         user = User(user_id='user', device_id='device')
         results = {}
-        result1 = FlagResult(value='on', is_default_variant=False)
-        result2 = FlagResult(value='control', is_default_variant=True)
+        result1 = FlagResult({'variant': {'key': 'on'}, 'isDefaultVariant': False})
+        result2 = FlagResult({'variant': {'key': 'control'}, 'isDefaultVariant': True})
         results['flag-key-1'] = result1
         results['flag-key-2'] = result2
         assignment1 = Assignment(user, results)
@@ -35,8 +35,8 @@ def test_same_user_different_results(self):
         user = User(user_id='user', device_id='device')
         results1 = {}
         results2 = {}
-        result1 = FlagResult(value='on', is_default_variant=False)
-        result2 = FlagResult(value='control', is_default_variant=True)
+        result1 = FlagResult({'variant': {'key': 'on'}, 'isDefaultVariant': False})
+        result2 = FlagResult({'variant': {'key': 'control'}, 'isDefaultVariant': True})
         results1['flag-key-1'] = result1
         results1['flag-key-2'] = result2
         results2['flag-key-2'] = result1
@@ -51,8 +51,8 @@ def test_same_results_different_users(self):
         user1 = User(user_id='user', device_id='device')
         user2 = User(user_id='different user', device_id='device')
         results = {}
-        result1 = FlagResult(value='on', is_default_variant=False)
-        result2 = FlagResult(value='control', is_default_variant=True)
+        result1 = FlagResult({'variant': {'key': 'on'}, 'isDefaultVariant': False})
+        result2 = FlagResult({'variant': {'key': 'control'}, 'isDefaultVariant': True})
         results['flag-key-1'] = result1
         results['flag-key-2'] = result2
         assignment1 = Assignment(user1, results)
@@ -76,8 +76,8 @@ def test_duplicate_assignments_with_different_ordering(self):
         user = User(user_id='user', device_id='device')
         results1 = {}
         results2 = {}
-        result1 = FlagResult(value='on', is_default_variant=False)
-        result2 = FlagResult(value='control', is_default_variant=True)
+        result1 = FlagResult({'variant': {'key': 'on'}, 'isDefaultVariant': False})
+        result2 = FlagResult({'variant': {'key': 'control'}, 'isDefaultVariant': True})
         results1['flag-key-1'] = result1
         results1['flag-key-2'] = result2
         results2['flag-key-2'] = result2
@@ -93,8 +93,8 @@ def test_lru_replacement(self):
         user2 = User(user_id='user2', device_id='device')
         user3 = User(user_id='user3', device_id='device')
         results = {}
-        result1 = FlagResult(value='on', is_default_variant=False)
-        result2 = FlagResult(value='control', is_default_variant=True)
+        result1 = FlagResult({'variant': {'key': 'on'}, 'isDefaultVariant': False})
+        result2 = FlagResult({'variant': {'key': 'control'}, 'isDefaultVariant': True})
         results['flag-key-1'] = result1
         results['flag-key-2'] = result2
         assignment1 = Assignment(user1, results)
@@ -110,8 +110,8 @@ def test_lru_expiration(self):
         user1 = User(user_id='user1', device_id='device')
         user2 = User(user_id='user2', device_id='device')
         results = {}
-        result1 = FlagResult(value='on', is_default_variant=False)
-        result2 = FlagResult(value='control', is_default_variant=True)
+        result1 = FlagResult({'variant': {'key': 'on'}, 'isDefaultVariant': False})
+        result2 = FlagResult({'variant': {'key': 'control'}, 'isDefaultVariant': True})
         results['flag-key-1'] = result1
         results['flag-key-2'] = result2
         assignment1 = Assignment(user1, results)

tests/local/assignment/assignment_service_test.py

@@ -5,6 +5,7 @@
 
 from src.amplitude_experiment import User, FlagResult
 from src.amplitude_experiment.assignment import AssignmentFilter, Assignment, DAY_MILLIS, to_event, AssignmentService
+from src.amplitude_experiment.util import hash_code
 
 user = User(user_id='user', device_id='device')
 
@@ -13,8 +14,8 @@ class AssignmentServiceTestCase(unittest.TestCase):
 
     def test_to_event(self):
         results = {}
-        result1 = FlagResult(value='on', is_default_variant=False)
-        result2 = FlagResult(value='control', is_default_variant=True)
+        result1 = FlagResult({'variant': {'key': 'on'}, 'isDefaultVariant': False})
+        result2 = FlagResult({'variant': {'key': 'control'}, 'isDefaultVariant': True})
         results['flag-key-1'] = result1
         results['flag-key-2'] = result2
         assignment = Assignment(user, results)
@@ -31,7 +32,7 @@ def test_to_event(self):
         self.assertEqual(1, len(user_properties['$set']))
         self.assertEqual(1, len(user_properties['$unset']))
         canonicalization = 'user device flag-key-1 on flag-key-2 control '
-        expected = f'user device {hash(canonicalization)} {assignment.timestamp / DAY_MILLIS}'
+        expected = f'user device {hash_code(canonicalization)} {int(assignment.timestamp / DAY_MILLIS)}'
         self.assertEqual(expected, event.insert_id)
 
     def test_tracking_called(self):