Merge pull request #2 from featbit/feature/1.0.1

feature/1.0.1

Author: deleteLater

fbclient/client.py

@@ -13,7 +13,7 @@
 from fbclient.event_processor import DefaultEventProcessor, NullEventProcessor
 from fbclient.event_types import FlagEvent, Metric, MetricEvent, UserEvent
 from fbclient.interfaces import DataUpdateStatusProvider
-from fbclient.status import DataUpdateStatusProviderIml
+from fbclient.status import DataUpdateStatusProviderImpl
 from fbclient.status_types import State
 from fbclient.streaming import Streaming, _data_to_dict
 from fbclient.update_processor import NullUpdateProcessor
@@ -79,7 +79,7 @@ def __init__(self, config: Config, start_wait: float = 15.):
         self._evaluator = Evaluator(lambda key: self._data_storage.get(FEATURE_FLAGS, key),
                                     lambda key: self._data_storage.get(SEGMENTS, key))
         # data updator and status provider
-        self._update_status_provider = DataUpdateStatusProviderIml(config.data_storage)
+        self._update_status_provider = DataUpdateStatusProviderImpl(config.data_storage)
         # update processor
         update_processor_ready = threading.Event()
         self._update_processor = self._build_update_processor(config, self._update_status_provider,

fbclient/common_types.py

@@ -38,7 +38,8 @@ def __init__(self, key: Optional[str], name: Optional[str], **kwargs):
         self._customs = {}
         if len(kwargs) > 0:
             self._customs \
-                .update(dict((k, str(v)) for k, v in kwargs.items() if isinstance(k, str) and k.lower() not in __BUILTINS_MAPING__.keys() and (isinstance(v, str) or is_numeric(v))))
+                .update(dict((k, str(v)) for k, v in kwargs.items() if isinstance(k, str) and k.lower() not in __BUILTINS_MAPING__.keys()
+                             and (isinstance(v, str) or is_numeric(v) or isinstance(v, bool))))
 
     @staticmethod
     def from_dict(user: Dict[str, Any]) -> "FBUser":

fbclient/evaluator.py

@@ -1,7 +1,6 @@
-import base64
 import json
 import re
-from typing import Callable, Iterable, Optional
+from typing import Callable, Optional
 
 from fbclient.common_types import FBEvent, FBUser, _EvalResult
 from fbclient.event_types import FlagEventVariation
@@ -67,6 +66,8 @@
 
 __NOT_IN_SEGMENT_CLAUSE__ = 'User is not in segment'
 
+__EXPT_KEY_PREFIX__ = "expt"
+
 
 class Evaluator:
     def __init__(self,
@@ -127,23 +128,19 @@ def _match_condition_user_variation(self, flag: dict, user: FBUser) -> Optional[
         for rule in flag['rules']:
             if self._match_any_rule(user, rule):
                 return self._get_rollout_variation_option(flag,
-                                                          rule['variations'],
+                                                          rule,
                                                           user,
                                                           REASON_RULE_MATCH,
-                                                          flag['exptIncludeAllTargets'],
-                                                          rule['includedInExpt'],
                                                           flag['key'],
                                                           flag['name'])
         return None
 
     # get value from default rule
     def _match_default_user_variation(self, flag: dict, user: FBUser) -> Optional[_EvalResult]:
         return self._get_rollout_variation_option(flag,
-                                                  flag['fallthrough']['variations'],
+                                                  flag['fallthrough'],
                                                   user,
                                                   REASON_FALLTHROUGH,
-                                                  flag['exptIncludeAllTargets'],
-                                                  flag['fallthrough']['includedInExpt'],
                                                   flag['key'],
                                                   flag['name'])
 
@@ -264,15 +261,13 @@ def match_segment(user: FBUser, segment: Optional[dict]) -> bool:
 
     def _get_rollout_variation_option(self,
                                       flag: dict,
-                                      rollouts: Iterable[dict],
+                                      rollout_variations: dict,
                                       user: FBUser,
                                       reason: str,
-                                      expt_include_all_targets: bool,
-                                      rule_inclued_in_expt: bool,
                                       key_name: str,
                                       name: str) -> Optional[_EvalResult]:
 
-        def is_send_to_expt(user_key: str,
+        def is_send_to_expt(dispatch_key: str,
                             rollout: dict,
                             expt_include_all_targets: bool,
                             rule_inclued_in_expt: bool) -> bool:
@@ -288,14 +283,16 @@ def is_send_to_expt(user_key: str,
                 upper_bound = send_to_expt_percentage / splitting_percentage
                 if upper_bound > 1:
                     upper_bound = 1
-                new_user_key = base64.b64encode(user_key.encode()).decode()
-                return VariationSplittingAlgorithm(new_user_key, [0, upper_bound]).is_key_belongs_to_percentage()
+                new_dispatch_key = "".join((__EXPT_KEY_PREFIX__, dispatch_key))
+                return VariationSplittingAlgorithm(new_dispatch_key, [0, upper_bound]).is_key_belongs_to_percentage()
             return False
 
-        user_key = user.get('keyid')
-        for rollout in rollouts:
-            if VariationSplittingAlgorithm(user_key, rollout['rollout']).is_key_belongs_to_percentage():  # type: ignore
-                send_to_expt = is_send_to_expt(user_key, rollout, expt_include_all_targets, rule_inclued_in_expt)  # type: ignore
+        dispatch_key = rollout_variations.get('dispatchKey')
+        dispatch_key = dispatch_key if dispatch_key else 'keyid'
+        dispatch_key_value = "".join((flag['key'], user.get(dispatch_key, "")))  # type: ignore
+        for rollout in rollout_variations['variations']:
+            if VariationSplittingAlgorithm(dispatch_key_value, rollout['rollout']).is_key_belongs_to_percentage():  # type: ignore
+                send_to_expt = is_send_to_expt(dispatch_key_value, rollout, flag['exptIncludeAllTargets'], rollout_variations['includedInExpt'])  # type: ignore
                 return _EvalResult(rollout['id'],
                                    flag['variationMap'][rollout['id']],
                                    reason,

fbclient/status.py

@@ -9,7 +9,7 @@
 from fbclient.utils import log
 
 
-class DataUpdateStatusProviderIml(DataUpdateStatusProvider):
+class DataUpdateStatusProviderImpl(DataUpdateStatusProvider):
 
     def __init__(self, storage: DataStorage):
         self.__storage = storage

fbclient/utils/__init__.py

@@ -133,16 +133,15 @@ def cast_variation_by_flag_type(flag_type: Optional[str], variation: Optional[st
 
 
 def simple_type_inference(value: Any) -> Optional[str]:
-    try:
-        if isinstance(value, bool):
-            return 'boolean'
-        elif isinstance(value, str):
-            return 'string'
-        elif isinstance(value, Iterable) or isinstance(value, Mapping):
-            return 'json'
-        elif is_numeric(str(value)):
-            return 'number'
-        else:
-            return None
-    except:
+    if isinstance(value, bool):
+        return 'boolean'
+    elif isinstance(value, str):
+        return 'string'
+    elif isinstance(value, Iterable) or isinstance(value, Mapping):
+        return 'json'
+    elif is_numeric(value):
+        return 'number'
+    elif value is None:
         return None
+    else:
+        raise ValueError("value type is not supported")

fbclient/utils/exceptions.py

@@ -20,6 +20,6 @@ def is_key_belongs_to_percentage(self) -> bool:
             return False
 
     def __percentage_of_key(self) -> float:
-        digest = hashlib.md5(self.__key.encode(encoding='ascii')).digest()
+        digest = hashlib.md5(self.__key.encode(encoding='utf-8')).digest()
         magic_num = int.from_bytes(digest[:4], byteorder='little', signed=True)
         return abs(magic_num / __MIN_INT__)

fbclient/utils/variation_splitting_algorithm.py

@@ -1 +1 @@
-VERSION = "1.0.0"
+VERSION = "1.0.1"