Update feature in client and input_validator

Author: chillaq

splitio/client/client.py

@@ -78,7 +78,7 @@ def _evaluate_if_ready(self, matching_key, bucketing_key, feature, attributes=No
             attributes
         )
 
-    def _make_evaluation(self, key, feature, attributes, method_name, metric_name):
+    def _make_evaluation(self, key, feature_flag, attributes, method_name, metric_name):
         try:
             if self.destroyed:
                 _LOGGER.error("Client has already been destroyed - no calls possible")
@@ -90,23 +90,23 @@ def _make_evaluation(self, key, feature, attributes, method_name, metric_name):
             start = get_current_epoch_time_ms()
 
             matching_key, bucketing_key = input_validator.validate_key(key, method_name)
-            feature = input_validator.validate_feature_name(
-                feature,
+            feature_flag = input_validator.validate_feature_name(
+                feature_flag,
                 self.ready,
                 self._factory._get_storage('splits'),  # pylint: disable=protected-access
                 method_name
             )
 
             if (matching_key is None and bucketing_key is None) \
-                    or feature is None \
+                    or feature_flag is None \
                     or not input_validator.validate_attributes(attributes, method_name):
                 return CONTROL, None
 
-            result = self._evaluate_if_ready(matching_key, bucketing_key, feature, attributes)
+            result = self._evaluate_if_ready(matching_key, bucketing_key, feature_flag, attributes)
 
             impression = self._build_impression(
                 matching_key,
-                feature,
+                feature_flag,
                 result['treatment'],
                 result['impression']['label'],
                 result['impression']['change_number'],
@@ -123,7 +123,7 @@ def _make_evaluation(self, key, feature, attributes, method_name, metric_name):
             try:
                 impression = self._build_impression(
                     matching_key,
-                    feature,
+                    feature_flag,
                     CONTROL,
                     Label.EXCEPTION,
                     self._split_storage.get_change_number(),
@@ -136,57 +136,57 @@ def _make_evaluation(self, key, feature, attributes, method_name, metric_name):
                 _LOGGER.debug('Error: ', exc_info=True)
             return CONTROL, None
 
-    def _make_evaluations(self, key, features, attributes, method_name, metric_name):
+    def _make_evaluations(self, key, feature_flags, attributes, method_name, metric_name):
         if self.destroyed:
             _LOGGER.error("Client has already been destroyed - no calls possible")
-            return input_validator.generate_control_treatments(features, method_name)
+            return input_validator.generate_control_treatments(feature_flags, method_name)
         if self._factory._waiting_fork():
             _LOGGER.error("Client is not ready - no calls possible")
-            return input_validator.generate_control_treatments(features, method_name)
+            return input_validator.generate_control_treatments(feature_flags, method_name)
 
         start = get_current_epoch_time_ms()
 
         matching_key, bucketing_key = input_validator.validate_key(key, method_name)
         if matching_key is None and bucketing_key is None:
-            return input_validator.generate_control_treatments(features, method_name)
+            return input_validator.generate_control_treatments(feature_flags, method_name)
 
         if input_validator.validate_attributes(attributes, method_name) is False:
-            return input_validator.generate_control_treatments(features, method_name)
+            return input_validator.generate_control_treatments(feature_flags, method_name)
 
-        features, missing = input_validator.validate_features_get_treatments(
+        feature_flags, missing = input_validator.validate_features_get_treatments(
             method_name,
-            features,
+            feature_flags,
             self.ready,
             self._factory._get_storage('splits')  # pylint: disable=protected-access
         )
-        if features is None:
+        if feature_flags is None:
             return {}
 
         bulk_impressions = []
         treatments = {name: (CONTROL, None) for name in missing}
 
         try:
             evaluations = self._evaluate_features_if_ready(matching_key, bucketing_key,
-                                                           list(features), attributes)
+                                                           list(feature_flags), attributes)
 
-            for feature in features:
+            for feature_flag in feature_flags:
                 try:
-                    result = evaluations[feature]
+                    result = evaluations[feature_flag]
                     impression = self._build_impression(matching_key,
-                                                        feature,
+                                                        feature_flag,
                                                         result['treatment'],
                                                         result['impression']['label'],
                                                         result['impression']['change_number'],
                                                         bucketing_key,
                                                         utctime_ms())
 
                     bulk_impressions.append(impression)
-                    treatments[feature] = (result['treatment'], result['configurations'])
+                    treatments[feature_flag] = (result['treatment'], result['configurations'])
 
                 except Exception:  # pylint: disable=broad-except
                     _LOGGER.error('%s: An exception occured when evaluating '
-                                  'feature flag %s returning CONTROL.' % (method_name, feature))
-                    treatments[feature] = CONTROL, None
+                                  'feature flag %s returning CONTROL.' % (method_name, feature_flag))
+                    treatments[feature_flag] = CONTROL, None
                     _LOGGER.debug('Error: ', exc_info=True)
                     continue
 
@@ -210,28 +210,28 @@ def _make_evaluations(self, key, features, attributes, method_name, metric_name)
             self._telemetry_evaluation_producer.record_exception(metric_name)
             _LOGGER.error('Error getting treatment for feature flags')
             _LOGGER.debug('Error: ', exc_info=True)
-        return input_validator.generate_control_treatments(list(features), method_name)
+        return input_validator.generate_control_treatments(list(feature_flags), method_name)
 
-    def _evaluate_features_if_ready(self, matching_key, bucketing_key, features, attributes=None):
+    def _evaluate_features_if_ready(self, matching_key, bucketing_key, feature_flags, attributes=None):
         if not self.ready:
             self._telemetry_init_producer.record_not_ready_usage()
             return {
-                feature: {
+                feature_flag: {
                     'treatment': CONTROL,
                     'configurations': None,
                     'impression': {'label': Label.NOT_READY, 'change_number': None}
                 }
-                for feature in features
+                for feature_flag in feature_flags
             }
 
         return self._evaluator.evaluate_features(
-            features,
+            feature_flags,
             matching_key,
             bucketing_key,
             attributes
         )
 
-    def get_treatment_with_config(self, key, feature, attributes=None):
+    def get_treatment_with_config(self, key, feature_flag, attributes=None):
         """
         Get the treatment and config for a feature flag and key, with optional dictionary of attributes.
 
@@ -247,10 +247,10 @@ def get_treatment_with_config(self, key, feature, attributes=None):
         :return: The treatment for the key and feature flag
         :rtype: tuple(str, str)
         """
-        return self._make_evaluation(key, feature, attributes, 'get_treatment_with_config',
+        return self._make_evaluation(key, feature_flag, attributes, 'get_treatment_with_config',
                                      MethodExceptionsAndLatencies.TREATMENT_WITH_CONFIG)
 
-    def get_treatment(self, key, feature, attributes=None):
+    def get_treatment(self, key, feature_flag, attributes=None):
         """
         Get the treatment for a feature flag and key, with an optional dictionary of attributes.
 
@@ -266,11 +266,11 @@ def get_treatment(self, key, feature, attributes=None):
         :return: The treatment for the key and feature flag
         :rtype: str
         """
-        treatment, _ = self._make_evaluation(key, feature, attributes, 'get_treatment',
+        treatment, _ = self._make_evaluation(key, feature_flag, attributes, 'get_treatment',
                                              MethodExceptionsAndLatencies.TREATMENT)
         return treatment
 
-    def get_treatments_with_config(self, key, features, attributes=None):
+    def get_treatments_with_config(self, key, feature_flags, attributes=None):
         """
         Evaluate multiple feature flags and return a dict with feature flag -> (treatment, config).
 
@@ -286,10 +286,10 @@ def get_treatments_with_config(self, key, features, attributes=None):
         :return: Dictionary with the result of all the feature flags provided
         :rtype: dict
         """
-        return self._make_evaluations(key, features, attributes, 'get_treatments_with_config',
+        return self._make_evaluations(key, feature_flags, attributes, 'get_treatments_with_config',
                                       MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG)
 
-    def get_treatments(self, key, features, attributes=None):
+    def get_treatments(self, key, feature_flags, attributes=None):
         """
         Evaluate multiple feature flags and return a dictionary with all the feature flag/treatments.
 
@@ -305,14 +305,14 @@ def get_treatments(self, key, features, attributes=None):
         :return: Dictionary with the result of all the feature flags provided
         :rtype: dict
         """
-        with_config = self._make_evaluations(key, features, attributes, 'get_treatments',
+        with_config = self._make_evaluations(key, feature_flags, attributes, 'get_treatments',
                                              MethodExceptionsAndLatencies.TREATMENTS)
-        return {feature: result[0] for (feature, result) in with_config.items()}
+        return {feature_flag: result[0] for (feature_flag, result) in with_config.items()}
 
     def _build_impression(  # pylint: disable=too-many-arguments
             self,
             matching_key,
-            feature_name,
+            feature_flag_name,
             treatment,
             label,
             change_number,
@@ -324,7 +324,7 @@ def _build_impression(  # pylint: disable=too-many-arguments
             label = None
 
         return Impression(
-            matching_key=matching_key, feature_name=feature_name,
+            matching_key=matching_key, feature_name=feature_flag_name,
             treatment=treatment, label=label, change_number=change_number,
             bucketing_key=bucketing_key, time=imp_time
         )

splitio/client/input_validator.py

@@ -303,7 +303,7 @@ def validate_traffic_type(traffic_type, should_validate_existance, split_storage
         _LOGGER.warning(
             'track: Traffic Type %s does not have any corresponding Feature flags in this environment, '
             'make sure you\'re tracking your events to a valid traffic type defined '
-            'in the Split console.',
+            'in the Split user interface.',
             traffic_type
         )