polishing

Author: chillaq

splitio/client/client.py

@@ -219,6 +219,9 @@ def _get_fallback_eval_results(self, eval_result, feature):
                                                                          feature, result["treatment"], result["impression"]["label"], _LOGGER)
         return result
 
+    def _check_impression_label(self, result):
+        return result['impression']['label'] == None or (result['impression']['label'] != None and result['impression']['label'].find(Label.SPLIT_NOT_FOUND) == -1)
+    
 class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
     """Entry point for the split sdk."""
 
@@ -344,7 +347,7 @@ def _get_treatment(self, method, key, feature, attributes=None, evaluation_optio
                 result = self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, feature)
 
         properties = self._get_properties(evaluation_options)
-        if result['impression']['label'] == None or (result['impression']['label'] != None and result['impression']['label'].find(Label.SPLIT_NOT_FOUND) == -1):
+        if self._check_impression_label(result):
             impression_decorated = self._build_impression(key, bucketing, feature, result, properties)
             self._record_stats([(impression_decorated, attributes)], start, method)
 
@@ -844,7 +847,7 @@ async def _get_treatment(self, method, key, feature, attributes=None, evaluation
                 result = self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, feature)
 
         properties = self._get_properties(evaluation_options)
-        if result['impression']['label'] == None or (result['impression']['label'] != None and result['impression']['label'].find(Label.SPLIT_NOT_FOUND) == -1):
+        if self._check_impression_label(result):
             impression_decorated = self._build_impression(key, bucketing, feature, result, properties)
             await self._record_stats([(impression_decorated, attributes)], start, method)
         return result['treatment'], result['configurations']

splitio/client/config.py

@@ -5,7 +5,7 @@
 
 from splitio.engine.impressions import ImpressionsMode
 from splitio.client.input_validator import validate_flag_sets, validate_fallback_treatment, validate_regex_name
-from splitio.models.fallback_config import FallbackConfig, FallbackTreatmentsConfiguration
+from splitio.models.fallback_config import FallbackTreatmentsConfiguration
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_DATA_SAMPLING = 1
@@ -71,7 +71,7 @@ class AuthenticateScheme(Enum):
     'httpAuthenticateScheme': AuthenticateScheme.NONE,
     'kerberosPrincipalUser': None,
     'kerberosPrincipalPassword': None,
-    'fallbackTreatmentsConfiguration': FallbackTreatmentsConfiguration(None)
+    'fallbackTreatments': FallbackTreatmentsConfiguration(None)
 }
 
 def _parse_operation_mode(sdk_key, config):
@@ -175,32 +175,26 @@ def sanitize(sdk_key, config):
     return processed
 
 def _sanitize_fallback_config(config, processed):
-    if config.get('fallbackTreatmentsConfiguration') is not None:
-        if not isinstance(config['fallbackTreatmentsConfiguration'], FallbackTreatmentsConfiguration):
-            _LOGGER.warning('Config: fallbackTreatmentsConfiguration parameter should be of `FallbackTreatmentsConfiguration` class.')
-            processed['fallbackTreatmentsConfiguration'] = FallbackTreatmentsConfiguration(None)
+    if config.get('fallbackTreatments') is not None:
+        if not isinstance(config['fallbackTreatments'], FallbackTreatmentsConfiguration):
+            _LOGGER.warning('Config: fallbackTreatments parameter should be of `FallbackTreatmentsConfiguration` class.')
+            processed['fallbackTreatments'] = None
             return processed        
-    
-        if config['fallbackTreatmentsConfiguration'].fallback_config != None:
-            if not isinstance(config['fallbackTreatmentsConfiguration'].fallback_config, FallbackConfig):
-                _LOGGER.warning('Config: fallback_config parameter should be of `FallbackConfig` class.')
-                processed['fallbackTreatmentsConfiguration'].fallback_config = FallbackConfig(None, None)
-                return processed        
-            
-            if config['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment is not None and not validate_fallback_treatment(config['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment):
-                _LOGGER.warning('Config: global fallbacktreatment parameter is discarded.')
-                processed['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment = None
-                return processed
-            
-            if config['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment is not None:
-                sanitized_flag_fallback_treatments = {}
-                for feature_name in config['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment.keys():
-                    if not validate_regex_name(feature_name) or not validate_fallback_treatment(config['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment[feature_name]):
-                        _LOGGER.warning('Config: fallback treatment parameter for feature flag %s is discarded.', feature_name)
-                        continue
-                                    
-                    sanitized_flag_fallback_treatments[feature_name] = config['fallbackTreatmentsConfiguration'].fallback_config.by_flag_fallback_treatment[feature_name]
-
-                processed['fallbackTreatmentsConfiguration'].fallback_config = FallbackConfig(config['fallbackTreatmentsConfiguration'].fallback_config.global_fallback_treatment, sanitized_flag_fallback_treatments)
-    
+        
+        sanitized_global_fallback_treatment = config['fallbackTreatments'].global_fallback_treatment
+        if config['fallbackTreatments'].global_fallback_treatment is not None and not validate_fallback_treatment(config['fallbackTreatments'].global_fallback_treatment):
+            _LOGGER.warning('Config: global fallbacktreatment parameter is discarded.')
+            sanitized_global_fallback_treatment = None
+        
+        sanitized_flag_fallback_treatments = {}
+        if config['fallbackTreatments'].by_flag_fallback_treatment is not None:
+            for feature_name in config['fallbackTreatments'].by_flag_fallback_treatment.keys():
+                if not validate_regex_name(feature_name) or not validate_fallback_treatment(config['fallbackTreatments'].by_flag_fallback_treatment[feature_name]):
+                    _LOGGER.warning('Config: fallback treatment parameter for feature flag %s is discarded.', feature_name)
+                    continue
+                                
+                sanitized_flag_fallback_treatments[feature_name] = config['fallbackTreatments'].by_flag_fallback_treatment[feature_name]
+
+        processed['fallbackTreatments'] = FallbackTreatmentsConfiguration(sanitized_global_fallback_treatment, sanitized_flag_fallback_treatments)
+
     return processed

splitio/client/factory.py

@@ -628,15 +628,15 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
 
         return SplitFactory(api_key, storages, cfg['labelsEnabled'],
                             recorder, manager, None, telemetry_producer, telemetry_init_producer, telemetry_submitter, preforked_initialization=preforked_initialization,
-                            fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration'])
+                            fallback_treatments_configuration=cfg['fallbackTreatments'])
 
     initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer", daemon=True)
     initialization_thread.start()
 
     return SplitFactory(api_key, storages, cfg['labelsEnabled'],
                         recorder, manager, sdk_ready_flag,
                         telemetry_producer, telemetry_init_producer,
-                        telemetry_submitter, fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration'])
+                        telemetry_submitter, fallback_treatments_configuration=cfg['fallbackTreatments'])
 
 async def _build_in_memory_factory_async(api_key, cfg, sdk_url=None, events_url=None,  # pylint:disable=too-many-arguments,too-many-localsa
                              auth_api_base_url=None, streaming_api_base_url=None, telemetry_api_base_url=None,
@@ -755,7 +755,7 @@ async def _build_in_memory_factory_async(api_key, cfg, sdk_url=None, events_url=
                         recorder, manager,
                         telemetry_producer, telemetry_init_producer,
                         telemetry_submitter, manager_start_task=manager_start_task,
-                        api_client=http_client, fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration'])
+                        api_client=http_client, fallback_treatments_configuration=cfg['fallbackTreatments'])
 
 def _build_redis_factory(api_key, cfg):
     """Build and return a split factory with redis-based storage."""
@@ -834,7 +834,7 @@ def _build_redis_factory(api_key, cfg):
         sdk_ready_flag=None,
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_init_producer,
-        fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration']
+        fallback_treatments_configuration=cfg['fallbackTreatments']
     )
     redundant_factory_count, active_factory_count = _get_active_and_redundant_count()
     storages['telemetry'].record_active_and_redundant_factories(active_factory_count, redundant_factory_count)
@@ -917,7 +917,7 @@ async def _build_redis_factory_async(api_key, cfg):
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_init_producer,
         telemetry_submitter=telemetry_submitter,
-        fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration']
+        fallback_treatments_configuration=cfg['fallbackTreatments']
     )
     redundant_factory_count, active_factory_count = _get_active_and_redundant_count()
     await storages['telemetry'].record_active_and_redundant_factories(active_factory_count, redundant_factory_count)
@@ -1000,7 +1000,7 @@ def _build_pluggable_factory(api_key, cfg):
         sdk_ready_flag=None,
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_init_producer,
-        fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration']
+        fallback_treatments_configuration=cfg['fallbackTreatments']
     )
     redundant_factory_count, active_factory_count = _get_active_and_redundant_count()
     storages['telemetry'].record_active_and_redundant_factories(active_factory_count, redundant_factory_count)
@@ -1081,7 +1081,7 @@ async def _build_pluggable_factory_async(api_key, cfg):
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_init_producer,
         telemetry_submitter=telemetry_submitter,
-        fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration']
+        fallback_treatments_configuration=cfg['fallbackTreatments']
     )
     redundant_factory_count, active_factory_count = _get_active_and_redundant_count()
     await storages['telemetry'].record_active_and_redundant_factories(active_factory_count, redundant_factory_count)
@@ -1159,7 +1159,7 @@ def _build_localhost_factory(cfg):
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
         telemetry_submitter=LocalhostTelemetrySubmitter(),
-        fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration']
+        fallback_treatments_configuration=cfg['fallbackTreatments']
     )
 
 async def _build_localhost_factory_async(cfg):
@@ -1231,7 +1231,7 @@ async def _build_localhost_factory_async(cfg):
         telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
         telemetry_submitter=LocalhostTelemetrySubmitterAsync(),
         manager_start_task=manager_start_task,
-        fallback_treatments_configuration=cfg['fallbackTreatmentsConfiguration']
+        fallback_treatments_configuration=cfg['fallbackTreatments']
     )
 
 def get_factory(api_key, **kwargs):

splitio/client/input_validator.py

@@ -9,6 +9,7 @@
 from splitio.client import client
 from splitio.client.util import get_fallback_treatment_and_label
 from splitio.engine.evaluator import CONTROL
+from splitio.models.fallback_treatment import FallbackTreatment
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -722,6 +723,14 @@ def validate_flag_sets(flag_sets, method_name):
     return list(sanitized_flag_sets)
 
 def validate_fallback_treatment(fallback_treatment):
+    if not isinstance(fallback_treatment, FallbackTreatment):
+        _LOGGER.warning("Config: Fallback treatment instance should be FallbackTreatment, input is discarded")
+        return False
+
+    if not isinstance(fallback_treatment.treatment, str):
+        _LOGGER.warning("Config: Fallback treatment value should be str type, input is discarded")
+        return False
+        
     if not validate_regex_name(fallback_treatment.treatment):
         _LOGGER.warning("Config: Fallback treatment should match regex %s", _FALLBACK_TREATMENT_REGEX)
         return False

splitio/client/util.py

@@ -53,20 +53,20 @@ def get_metadata(config):
     return SdkMetadata(version, hostname, ip_address)
 
 def get_fallback_treatment_and_label(fallback_treatments_configuration, feature_name, treatment, label, _logger):
-    if fallback_treatments_configuration == None or fallback_treatments_configuration.fallback_config == None:
+    if fallback_treatments_configuration == None:
         return label, treatment, None
 
-    if fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment != None and \
-        fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name) != None:
+    if fallback_treatments_configuration.by_flag_fallback_treatment != None and \
+        fallback_treatments_configuration.by_flag_fallback_treatment.get(feature_name) != None:
         _logger.debug('Using Fallback Treatment for feature: %s', feature_name)            
-        return fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).label_prefix + label, \
-            fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).treatment,  \
-            fallback_treatments_configuration.fallback_config.by_flag_fallback_treatment.get(feature_name).config
+        return fallback_treatments_configuration.by_flag_fallback_treatment.get(feature_name).label_prefix + label, \
+            fallback_treatments_configuration.by_flag_fallback_treatment.get(feature_name).treatment,  \
+            fallback_treatments_configuration.by_flag_fallback_treatment.get(feature_name).config
 
-    if fallback_treatments_configuration.fallback_config.global_fallback_treatment != None:
+    if fallback_treatments_configuration.global_fallback_treatment != None:
         _logger.debug('Using Global Fallback Treatment.')            
-        return  fallback_treatments_configuration.fallback_config.global_fallback_treatment.label_prefix + label, \
-            fallback_treatments_configuration.fallback_config.global_fallback_treatment.treatment,  \
-            fallback_treatments_configuration.fallback_config.global_fallback_treatment.config
+        return  fallback_treatments_configuration.global_fallback_treatment.label_prefix + label, \
+            fallback_treatments_configuration.global_fallback_treatment.treatment,  \
+            fallback_treatments_configuration.global_fallback_treatment.config
 
     return label, treatment, None

splitio/models/fallback_config.py

@@ -1,32 +1,7 @@
 """Segment module."""
 
 class FallbackTreatmentsConfiguration(object):
-    """FallbackConfiguration object class."""
-
-    def __init__(self, fallback_config):
-        """
-        Class constructor.
-
-        :param fallback_config: fallback config object.
-        :type fallback_config: FallbackConfig
-
-        :param by_flag_fallback_treatment: Dict of flags and their fallback treatment
-        :type by_flag_fallback_treatment: {str: FallbackTreatment}
-        """
-        self._fallback_config = fallback_config
-        
-    @property
-    def fallback_config(self):
-        """Return fallback config."""
-        return self._fallback_config
-    
-    @fallback_config.setter
-    def fallback_config(self, new_value):
-        """Set fallback config."""
-        self._fallback_config = new_value
-
-class FallbackConfig(object):
-    """FallbackConfig object class."""
+    """FallbackTreatmentsConfiguration object class."""
 
     def __init__(self, global_fallback_treatment=None, by_flag_fallback_treatment=None):
         """