splitio-client 10.4.0__tar.gz → 10.5.0__tar.gz

{splitio_client-10.4.0 → splitio_client-10.5.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: splitio_client
-Version: 10.4.0
+Version: 10.5.0
 Summary: Split.io Python Client
 Home-page: https://github.com/splitio/python-client
-Download-URL: https://github.com/splitio/python-client/tarball/10.4.0
+Download-URL: https://github.com/splitio/python-client/tarball/10.5.0
 Author: Patricio Echague, Sebastian Arrubia
 Author-email: pato@split.io, sebastian@split.io
 License: Apache License 2.0

{splitio_client-10.4.0 → splitio_client-10.5.0}/setup.py

@@ -45,7 +45,7 @@ setup(
     tests_require=TESTS_REQUIRES,
     extras_require={
         'test': TESTS_REQUIRES,
-        'redis': ['redis>=2.10.5'],
+        'redis': ['redis>=2.10.5,<7.0.0'],
         'uwsgi': ['uwsgi>=2.0.0'],
         'cpphash': ['mmh3cffi==0.2.1'],
         'asyncio': ['aiohttp>=3.8.4', 'aiofiles>=23.1.0'],

{splitio_client-10.4.0 → splitio_client-10.5.0}/splitio/client/client.py

@@ -2,6 +2,7 @@
 import logging
 import json
 from collections import namedtuple
+import copy
 
 from splitio.engine.evaluator import Evaluator, CONTROL, EvaluationDataFactory, AsyncEvaluationDataFactory
 from splitio.engine.splitters import Splitter
@@ -39,7 +40,7 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
         'impressions_disabled': False
     }
 
-    def __init__(self, factory, recorder, labels_enabled=True):
+    def __init__(self, factory, recorder, labels_enabled=True, fallback_treatment_calculator=None):
         """
         Construct a Client instance.
 
@@ -61,9 +62,10 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
         self._feature_flag_storage = factory._get_storage('splits')  # pylint: disable=protected-access
         self._segment_storage = factory._get_storage('segments')  # pylint: disable=protected-access
         self._events_storage = factory._get_storage('events')  # pylint: disable=protected-access
-        self._evaluator = Evaluator(self._splitter)
+        self._evaluator = Evaluator(self._splitter, fallback_treatment_calculator)
         self._telemetry_evaluation_producer = self._factory._telemetry_evaluation_producer
         self._telemetry_init_producer = self._factory._telemetry_init_producer
+        self._fallback_treatment_calculator = fallback_treatment_calculator
 
     @property
     def ready(self):
@@ -203,11 +205,26 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
     def _get_properties(self, evaluation_options):
         return evaluation_options.properties if evaluation_options != None else None
         
+    def _get_fallback_treatment_with_config(self, feature):
+        fallback_treatment = self._fallback_treatment_calculator.resolve(feature, "")
+        return fallback_treatment.treatment, fallback_treatment.config
+
+    def _get_fallback_eval_results(self, eval_result, feature):
+        result = copy.deepcopy(eval_result)
+        fallback_treatment = self._fallback_treatment_calculator.resolve(feature, result["impression"]["label"])
+        result["impression"]["label"] = fallback_treatment.label
+        result["treatment"] = fallback_treatment.treatment
+        result["configurations"] = fallback_treatment.config
+        
+        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."""
 
-    def __init__(self, factory, recorder, labels_enabled=True):
+    def __init__(self, factory, recorder, labels_enabled=True, fallback_treatment_calculator=None):
         """
         Construct a Client instance.
 
@@ -222,7 +239,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
 
         :rtype: Client
         """
-        ClientBase.__init__(self, factory, recorder, labels_enabled)
+        ClientBase.__init__(self, factory, recorder, labels_enabled, fallback_treatment_calculator)
         self._context_factory = EvaluationDataFactory(factory._get_storage('splits'), factory._get_storage('segments'), factory._get_storage('rule_based_segments'))
 
     def destroy(self):
@@ -254,10 +271,11 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
         try:
             treatment, _ = self._get_treatment(MethodExceptionsAndLatencies.TREATMENT, key, feature_flag_name, attributes, evaluation_options)
             return treatment
-
+    
         except:
             _LOGGER.error('get_treatment failed')
-            return CONTROL
+            treatment, _ = self._get_fallback_treatment_with_config(feature_flag_name)
+            return treatment
 
     def get_treatment_with_config(self, key, feature_flag_name, attributes=None, evaluation_options=None):
         """
@@ -282,8 +300,8 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
 
         except Exception:
             _LOGGER.error('get_treatment_with_config failed')
-            return CONTROL, None
-
+            return self._get_fallback_treatment_with_config(feature_flag_name)
+            
     def _get_treatment(self, method, key, feature, attributes=None, evaluation_options=None):
         """
         Validate key, feature flag name and object, and get the treatment and config with an optional dictionary of attributes.
@@ -302,7 +320,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
         :rtype: dict
         """
         if not self._client_is_usable(): # not destroyed & not waiting for a fork
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(feature)
 
         start = get_current_epoch_time_ms()
         if not self.ready:
@@ -312,9 +330,10 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
         try:
             key, bucketing, feature, attributes, evaluation_options = self._validate_treatment_input(key, feature, attributes, method, evaluation_options)
         except _InvalidInputError:
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(feature)
 
-        result = self._NON_READY_EVAL_RESULT
+        result = self._get_fallback_eval_results(self._NON_READY_EVAL_RESULT, feature)
+        
         if self.ready:
             try:
                 ctx = self._context_factory.context_for(key, [feature])
@@ -324,15 +343,15 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
                 _LOGGER.error('Error getting treatment for feature flag')
                 _LOGGER.debug('Error: ', exc_info=True)
                 self._telemetry_evaluation_producer.record_exception(method)
-                result = self._FAILED_EVAL_RESULT
+                result = self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, feature)
 
         properties = self._get_properties(evaluation_options)
-        if result['impression']['label'] != Label.SPLIT_NOT_FOUND:
+        if self._check_impression_label(result):
             impression_decorated = self._build_impression(key, bucketing, feature, result, properties)
             self._record_stats([(impression_decorated, attributes)], start, method)
 
         return result['treatment'], result['configurations']
-
+        
     def get_treatments(self, key, feature_flag_names, attributes=None, evaluation_options=None):
         """
         Evaluate multiple feature flags and return a dictionary with all the feature flag/treatments.
@@ -356,7 +375,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
             return {feature_flag: result[0] for (feature_flag, result) in with_config.items()}
 
         except Exception:
-            return {feature: CONTROL for feature in feature_flag_names}
+            return {feature: self._get_fallback_treatment_with_config(feature)[0] for feature in feature_flag_names}
 
     def get_treatments_with_config(self, key, feature_flag_names, attributes=None, evaluation_options=None):
         """
@@ -380,7 +399,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
             return self._get_treatments(key, feature_flag_names, MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG, attributes, evaluation_options)
 
         except Exception:
-            return {feature: (CONTROL, None) for feature in feature_flag_names}
+            return {feature: (self._get_fallback_treatment_with_config(feature)) for feature in feature_flag_names}
 
     def get_treatments_by_flag_set(self, key, flag_set, attributes=None, evaluation_options=None):
         """
@@ -604,7 +623,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
         """
         start = get_current_epoch_time_ms()
         if not self._client_is_usable():
-            return input_validator.generate_control_treatments(features)
+            return input_validator.generate_control_treatments(features, self._fallback_treatment_calculator)
 
         if not self.ready:
             _LOGGER.error("Client is not ready - no calls possible")
@@ -613,9 +632,9 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
         try:
             key, bucketing, features, attributes, evaluation_options = self._validate_treatments_input(key, features, attributes, method, evaluation_options)
         except _InvalidInputError:
-            return input_validator.generate_control_treatments(features)
+            return input_validator.generate_control_treatments(features, self._fallback_treatment_calculator)
 
-        results = {n: self._NON_READY_EVAL_RESULT for n in features}
+        results = {n: self._get_fallback_eval_results(self._NON_READY_EVAL_RESULT, n) for n in features}
         if self.ready:
             try:
                 ctx = self._context_factory.context_for(key, features)
@@ -625,12 +644,12 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
                 _LOGGER.error('Error getting treatment for feature flag')
                 _LOGGER.debug('Error: ', exc_info=True)
                 self._telemetry_evaluation_producer.record_exception(method)
-                results = {n: self._FAILED_EVAL_RESULT for n in features}
+                results = {n: self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, n) for n in features}
 
         properties = self._get_properties(evaluation_options)
         imp_decorated_attrs = [
             (i, attributes) for i in self._build_impressions(key, bucketing, results, properties)
-            if i.Impression.label != Label.SPLIT_NOT_FOUND
+            if i.Impression.label == None or (i.Impression.label != None and i.Impression.label.find(Label.SPLIT_NOT_FOUND)) == -1
         ]
         self._record_stats(imp_decorated_attrs, start, method)
 
@@ -706,7 +725,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
 class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
     """Entry point for the split sdk."""
 
-    def __init__(self, factory, recorder, labels_enabled=True):
+    def __init__(self, factory, recorder, labels_enabled=True, fallback_treatment_calculator=None):
         """
         Construct a Client instance.
 
@@ -721,7 +740,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
 
         :rtype: Client
         """
-        ClientBase.__init__(self, factory, recorder, labels_enabled)
+        ClientBase.__init__(self, factory, recorder, labels_enabled, fallback_treatment_calculator)
         self._context_factory = AsyncEvaluationDataFactory(factory._get_storage('splits'), factory._get_storage('segments'), factory._get_storage('rule_based_segments'))
 
     async def destroy(self):
@@ -756,7 +775,8 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
 
         except:
             _LOGGER.error('get_treatment failed')
-            return CONTROL
+            treatment, _ = self._get_fallback_treatment_with_config(feature_flag_name)
+            return treatment
 
     async def get_treatment_with_config(self, key, feature_flag_name, attributes=None, evaluation_options=None):
         """
@@ -781,7 +801,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
 
         except Exception:
             _LOGGER.error('get_treatment_with_config failed')
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(feature_flag_name)
 
     async def _get_treatment(self, method, key, feature, attributes=None, evaluation_options=None):
         """
@@ -801,7 +821,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
         :rtype: dict
         """
         if not self._client_is_usable(): # not destroyed & not waiting for a fork
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(feature)
 
         start = get_current_epoch_time_ms()
         if not self.ready:
@@ -811,9 +831,9 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
         try:
             key, bucketing, feature, attributes, evaluation_options = self._validate_treatment_input(key, feature, attributes, method, evaluation_options)
         except _InvalidInputError:
-            return CONTROL, None
+            return self._get_fallback_treatment_with_config(feature)
 
-        result = self._NON_READY_EVAL_RESULT
+        result = self._get_fallback_eval_results(self._NON_READY_EVAL_RESULT, feature)
         if self.ready:
             try:
                 ctx = await self._context_factory.context_for(key, [feature])
@@ -823,10 +843,10 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
                 _LOGGER.error('Error getting treatment for feature flag')
                 _LOGGER.debug('Error: ', exc_info=True)
                 await self._telemetry_evaluation_producer.record_exception(method)
-                result = self._FAILED_EVAL_RESULT
+                result = self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, feature)
 
         properties = self._get_properties(evaluation_options)
-        if result['impression']['label'] != Label.SPLIT_NOT_FOUND:
+        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']
@@ -854,7 +874,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
             return {feature_flag: result[0] for (feature_flag, result) in with_config.items()}
 
         except Exception:
-            return {feature: CONTROL for feature in feature_flag_names}
+            return {feature: self._get_fallback_treatment_with_config(feature)[0] for feature in feature_flag_names}
 
     async def get_treatments_with_config(self, key, feature_flag_names, attributes=None, evaluation_options=None):
         """
@@ -878,8 +898,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
             return await self._get_treatments(key, feature_flag_names, MethodExceptionsAndLatencies.TREATMENTS_WITH_CONFIG, attributes, evaluation_options)
 
         except Exception:
-            _LOGGER.error("AA", exc_info=True)
-            return {feature: (CONTROL, None) for feature in feature_flag_names}
+            return {feature: (self._get_fallback_treatment_with_config(feature)) for feature in feature_flag_names}
 
     async def get_treatments_by_flag_set(self, key, flag_set, attributes=None, evaluation_options=None):
         """
@@ -1017,7 +1036,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
         """
         start = get_current_epoch_time_ms()
         if not self._client_is_usable():
-            return input_validator.generate_control_treatments(features)
+            return input_validator.generate_control_treatments(features, self._fallback_treatment_calculator)
 
         if not self.ready:
             _LOGGER.error("Client is not ready - no calls possible")
@@ -1026,9 +1045,9 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
         try:
             key, bucketing, features, attributes, evaluation_options = self._validate_treatments_input(key, features, attributes, method, evaluation_options)
         except _InvalidInputError:
-            return input_validator.generate_control_treatments(features)
+            return input_validator.generate_control_treatments(features, self._fallback_treatment_calculator)
 
-        results = {n: self._NON_READY_EVAL_RESULT for n in features}
+        results = {n: self._get_fallback_eval_results(self._NON_READY_EVAL_RESULT, n) for n in features}
         if self.ready:
             try:
                 ctx = await self._context_factory.context_for(key, features)
@@ -1038,12 +1057,12 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
                 _LOGGER.error('Error getting treatment for feature flag')
                 _LOGGER.debug('Error: ', exc_info=True)
                 await self._telemetry_evaluation_producer.record_exception(method)
-                results = {n: self._FAILED_EVAL_RESULT for n in features}
+                results = {n: self._get_fallback_eval_results(self._FAILED_EVAL_RESULT, n) for n in features}
 
         properties = self._get_properties(evaluation_options)
         imp_decorated_attrs = [
             (i, attributes) for i in self._build_impressions(key, bucketing, results, properties)
-            if i.Impression.label != Label.SPLIT_NOT_FOUND
+            if i.Impression.label == None or (i.Impression.label != None and i.Impression.label.find(Label.SPLIT_NOT_FOUND)) == -1
         ]
         await self._record_stats(imp_decorated_attrs, start, method)
 

{splitio_client-10.4.0 → splitio_client-10.5.0}/splitio/client/config.py

@@ -4,7 +4,8 @@ import logging
 from enum import Enum
 
 from splitio.engine.impressions import ImpressionsMode
-from splitio.client.input_validator import validate_flag_sets
+from splitio.client.input_validator import validate_flag_sets, validate_fallback_treatment, validate_regex_name
+from splitio.models.fallback_config import FallbackTreatmentsConfiguration
 
 _LOGGER = logging.getLogger(__name__)
 DEFAULT_DATA_SAMPLING = 1
@@ -69,7 +70,8 @@ DEFAULT_CONFIG = {
     'flagSetsFilter': None,
     'httpAuthenticateScheme': AuthenticateScheme.NONE,
     'kerberosPrincipalUser': None,
-    'kerberosPrincipalPassword': None
+    'kerberosPrincipalPassword': None,
+    'fallbackTreatments': FallbackTreatmentsConfiguration(None)
 }
 
 def _parse_operation_mode(sdk_key, config):
@@ -168,4 +170,38 @@ def sanitize(sdk_key, config):
                             ' Defaulting to `none` mode.')
         processed["httpAuthenticateScheme"] = authenticate_scheme
 
+    processed = _sanitize_fallback_config(config, processed)    
+    
+    if config.get("redisErrors") is not None:
+        _LOGGER.warning('Parameter `redisErrors` is deprecated as it is no longer supported in redis lib.' \
+                        ' Will ignore this value.')
+        
+        processed["redisErrors"] = None
     return processed
+
+def _sanitize_fallback_config(config, processed):
+    if config.get('fallbackTreatments') is None:
+        return processed
+    
+    if not isinstance(config['fallbackTreatments'], FallbackTreatmentsConfiguration):
+        _LOGGER.warning('Config: fallbackTreatments parameter should be of `FallbackTreatmentsConfiguration` class.')
+        processed['fallbackTreatments'] = None
+        return processed        
+    
+    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-10.4.0 → splitio_client-10.5.0}/splitio/client/factory.py

@@ -18,7 +18,7 @@ from splitio.engine.telemetry import TelemetryStorageProducer, TelemetryStorageC
     TelemetryStorageProducerAsync, TelemetryStorageConsumerAsync
 from splitio.engine.impressions.manager import Counter as ImpressionsCounter
 from splitio.engine.impressions.unique_keys_tracker import UniqueKeysTracker, UniqueKeysTrackerAsync
-
+from splitio.models.fallback_config import FallbackTreatmentCalculator
 # Storage
 from splitio.storage.inmemmory import InMemorySplitStorage, InMemorySegmentStorage, \
     InMemoryImpressionStorage, InMemoryEventStorage, InMemoryTelemetryStorage, LocalhostTelemetryStorage, \
@@ -170,7 +170,8 @@ class SplitFactory(SplitFactoryBase):  # pylint: disable=too-many-instance-attri
             telemetry_producer=None,
             telemetry_init_producer=None,
             telemetry_submitter=None,
-            preforked_initialization=False
+            preforked_initialization=False,
+            fallback_treatment_calculator=None
     ):
         """
         Class constructor.
@@ -201,6 +202,7 @@ class SplitFactory(SplitFactoryBase):  # pylint: disable=too-many-instance-attri
         self._ready_time = get_current_epoch_time_ms()
         _LOGGER.debug("Running in threading mode")
         self._sdk_internal_ready_flag = sdk_ready_flag
+        self._fallback_treatment_calculator = fallback_treatment_calculator
         self._start_status_updater()
 
     def _start_status_updater(self):
@@ -242,7 +244,7 @@ class SplitFactory(SplitFactoryBase):  # pylint: disable=too-many-instance-attri
         This client is only a set of references to structures hold by the factory.
         Creating one a fast operation and safe to be used anywhere.
         """
-        return Client(self, self._recorder, self._labels_enabled)
+        return Client(self, self._recorder, self._labels_enabled, self._fallback_treatment_calculator)
 
     def manager(self):
         """
@@ -338,7 +340,8 @@ class SplitFactoryAsync(SplitFactoryBase):  # pylint: disable=too-many-instance-
             telemetry_init_producer=None,
             telemetry_submitter=None,
             manager_start_task=None,
-            api_client=None
+            api_client=None,
+            fallback_treatment_calculator=None
     ):
         """
         Class constructor.
@@ -372,6 +375,7 @@ class SplitFactoryAsync(SplitFactoryBase):  # pylint: disable=too-many-instance-
         self._sdk_ready_flag = asyncio.Event()
         self._ready_task = asyncio.get_running_loop().create_task(self._update_status_when_ready_async())
         self._api_client = api_client
+        self._fallback_treatment_calculator = fallback_treatment_calculator
 
     async def _update_status_when_ready_async(self):
         """Wait until the sdk is ready and update the status for async mode."""
@@ -460,7 +464,7 @@ class SplitFactoryAsync(SplitFactoryBase):  # pylint: disable=too-many-instance-
         This client is only a set of references to structures hold by the factory.
         Creating one a fast operation and safe to be used anywhere.
         """
-        return ClientAsync(self, self._recorder, self._labels_enabled)
+        return ClientAsync(self, self._recorder, self._labels_enabled, self._fallback_treatment_calculator)
 
 def _wrap_impression_listener(listener, metadata):
     """
@@ -623,7 +627,8 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
         synchronizer._split_synchronizers._segment_sync.shutdown()
 
         return SplitFactory(api_key, storages, cfg['labelsEnabled'],
-                            recorder, manager, None, telemetry_producer, telemetry_init_producer, telemetry_submitter, preforked_initialization=preforked_initialization)
+                            recorder, manager, None, telemetry_producer, telemetry_init_producer, telemetry_submitter, preforked_initialization=preforked_initialization,
+                            fallback_treatment_calculator=FallbackTreatmentCalculator(cfg['fallbackTreatments']))
 
     initialization_thread = threading.Thread(target=manager.start, name="SDKInitializer", daemon=True)
     initialization_thread.start()
@@ -631,7 +636,7 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
     return SplitFactory(api_key, storages, cfg['labelsEnabled'],
                         recorder, manager, sdk_ready_flag,
                         telemetry_producer, telemetry_init_producer,
-                        telemetry_submitter)
+                        telemetry_submitter, fallback_treatment_calculator = FallbackTreatmentCalculator(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,
@@ -750,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)
+                        api_client=http_client, fallback_treatment_calculator=FallbackTreatmentCalculator(cfg['fallbackTreatments']))
 
 def _build_redis_factory(api_key, cfg):
     """Build and return a split factory with redis-based storage."""
@@ -828,7 +833,8 @@ def _build_redis_factory(api_key, cfg):
         manager,
         sdk_ready_flag=None,
         telemetry_producer=telemetry_producer,
-        telemetry_init_producer=telemetry_init_producer
+        telemetry_init_producer=telemetry_init_producer,
+        fallback_treatment_calculator=FallbackTreatmentCalculator(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)
@@ -910,7 +916,8 @@ async def _build_redis_factory_async(api_key, cfg):
         manager,
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_init_producer,
-        telemetry_submitter=telemetry_submitter
+        telemetry_submitter=telemetry_submitter,
+        fallback_treatment_calculator=FallbackTreatmentCalculator(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)
@@ -992,7 +999,8 @@ def _build_pluggable_factory(api_key, cfg):
         manager,
         sdk_ready_flag=None,
         telemetry_producer=telemetry_producer,
-        telemetry_init_producer=telemetry_init_producer
+        telemetry_init_producer=telemetry_init_producer,
+        fallback_treatment_calculator=FallbackTreatmentCalculator(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)
@@ -1072,7 +1080,8 @@ async def _build_pluggable_factory_async(api_key, cfg):
         manager,
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_init_producer,
-        telemetry_submitter=telemetry_submitter
+        telemetry_submitter=telemetry_submitter,
+        fallback_treatment_calculator=FallbackTreatmentCalculator(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)
@@ -1150,6 +1159,7 @@ def _build_localhost_factory(cfg):
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
         telemetry_submitter=LocalhostTelemetrySubmitter(),
+        fallback_treatment_calculator=FallbackTreatmentCalculator(cfg['fallbackTreatments'])
     )
 
 async def _build_localhost_factory_async(cfg):
@@ -1220,7 +1230,8 @@ async def _build_localhost_factory_async(cfg):
         telemetry_producer=telemetry_producer,
         telemetry_init_producer=telemetry_producer.get_telemetry_init_producer(),
         telemetry_submitter=LocalhostTelemetrySubmitterAsync(),
-        manager_start_task=manager_start_task
+        manager_start_task=manager_start_task,
+        fallback_treatment_calculator=FallbackTreatmentCalculator(cfg['fallbackTreatments'])
     )
 
 def get_factory(api_key, **kwargs):

{splitio_client-10.4.0 → splitio_client-10.5.0}/splitio/client/input_validator.py

@@ -8,6 +8,7 @@ import inspect
 from splitio.client.key import Key
 from splitio.client import client
 from splitio.engine.evaluator import CONTROL
+from splitio.models.fallback_treatment import FallbackTreatment
 
 
 _LOGGER = logging.getLogger(__name__)
@@ -15,7 +16,8 @@ MAX_LENGTH = 250
 EVENT_TYPE_PATTERN = r'^[a-zA-Z0-9][-_.:a-zA-Z0-9]{0,79}$'
 MAX_PROPERTIES_LENGTH_BYTES = 32768
 _FLAG_SETS_REGEX = '^[a-z0-9][_a-z0-9]{0,49}$'
-
+_FALLBACK_TREATMENT_REGEX = '^[0-9]+[.a-zA-Z0-9_-]*$|^[a-zA-Z]+[a-zA-Z0-9_-]*$'
+_FALLBACK_TREATMENT_SIZE = 100
 
 def _check_not_null(value, name, operation):
     """
@@ -500,7 +502,7 @@ def validate_feature_flags_get_treatments(  # pylint: disable=invalid-name
         valid_feature_flags.append(ff)
     return valid_feature_flags
 
-def generate_control_treatments(feature_flags):
+def generate_control_treatments(feature_flags, fallback_treatment_calculator):
     """
     Generate valid feature flags to control.
 
@@ -515,7 +517,11 @@ def generate_control_treatments(feature_flags):
     to_return = {}
     for feature_flag in feature_flags:
         if isinstance(feature_flag, str) and len(feature_flag.strip())> 0:
-            to_return[feature_flag] = (CONTROL, None)
+            fallback_treatment = fallback_treatment_calculator.resolve(feature_flag, "")
+            treatment = fallback_treatment.treatment
+            config = fallback_treatment.config
+            
+            to_return[feature_flag] = (treatment, config)
     return to_return
 
 
@@ -712,3 +718,28 @@ def validate_flag_sets(flag_sets, method_name):
         sanitized_flag_sets.add(flag_set)
 
     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
+        
+    if len(fallback_treatment.treatment) > _FALLBACK_TREATMENT_SIZE:
+        _LOGGER.warning("Config: Fallback treatment size should not exceed %s characters", _FALLBACK_TREATMENT_SIZE)
+        return False
+                
+    return True
+
+def validate_regex_name(name):
+    if re.match(_FALLBACK_TREATMENT_REGEX, name) == None:
+        return False
+    
+    return True

{splitio_client-10.4.0 → splitio_client-10.5.0}/splitio/client/util.py

@@ -50,4 +50,4 @@ def get_metadata(config):
     """
     version = 'python-%s' % __version__
     ip_address, hostname = _get_hostname_and_ip(config)
-    return SdkMetadata(version, hostname, ip_address)
+    return SdkMetadata(version, hostname, ip_address)

{splitio_client-10.4.0 → splitio_client-10.5.0}/splitio/engine/evaluator.py

@@ -20,7 +20,7 @@ _LOGGER = logging.getLogger(__name__)
 class Evaluator(object):  # pylint: disable=too-few-public-methods
     """Split Evaluator class."""
 
-    def __init__(self, splitter):
+    def __init__(self, splitter, fallback_treatment_calculator=None):
         """
         Construct a Evaluator instance.
 
@@ -28,6 +28,7 @@ class Evaluator(object):  # pylint: disable=too-few-public-methods
         :type splitter: splitio.engine.splitters.Splitters
         """
         self._splitter = splitter
+        self._fallback_treatment_calculator = fallback_treatment_calculator
 
     def eval_many_with_context(self, key, bucketing, features, attrs, ctx):
         """
@@ -51,6 +52,10 @@ class Evaluator(object):  # pylint: disable=too-few-public-methods
         if not feature:
             _LOGGER.warning('Unknown or invalid feature: %s', feature)
             label = Label.SPLIT_NOT_FOUND
+            fallback_treatment = self._fallback_treatment_calculator.resolve(feature_name, label)
+            label = fallback_treatment.label
+            _treatment = fallback_treatment.treatment
+            config = fallback_treatment.config
         else:
             _change_number = feature.change_number
             if feature.killed:
@@ -59,17 +64,18 @@ class Evaluator(object):  # pylint: disable=too-few-public-methods
             else:
                 label, _treatment = self._check_prerequisites(feature, bucketing, key, attrs, ctx, label, _treatment)
                 label, _treatment = self._get_treatment(feature, bucketing, key, attrs, ctx, label, _treatment)
+            config = feature.get_configurations_for(_treatment)
                     
         return {
             'treatment': _treatment,
-            'configurations': feature.get_configurations_for(_treatment) if feature else None,
+            'configurations': config,
             'impression': {
                 'label': label,
                 'change_number': _change_number
             },
             'impressions_disabled': feature.impressions_disabled if feature else None
         }
-
+    
     def _get_treatment(self, feature, bucketing, key, attrs, ctx, label, _treatment):
         if _treatment == CONTROL:
             treatment, label = self._treatment_for_flag(feature, key, bucketing, attrs, ctx)