splitio-client 10.1.0rc3__tar.gz → 10.2.0__tar.gz

splitio_client-10.2.0/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright © 2025 Split Software, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

splitio_client-10.2.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: splitio_client
+Version: 10.2.0
+Summary: Split.io Python Client
+Home-page: https://github.com/splitio/python-client
+Download-URL: https://github.com/splitio/python-client/tarball/10.2.0
+Author: Patricio Echague, Sebastian Arrubia
+Author-email: pato@split.io, sebastian@split.io
+License: Apache License 2.0
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: requests
+Requires-Dist: pyyaml
+Requires-Dist: docopt>=0.6.2
+Requires-Dist: enum34; python_version < "3.4"
+Requires-Dist: bloom-filter2>=2.0.0
+Provides-Extra: test
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: pytest==7.0.1; extra == "test"
+Requires-Dist: pytest-mock==3.11.1; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest-cov==4.1.0; extra == "test"
+Requires-Dist: importlib-metadata==6.7; extra == "test"
+Requires-Dist: tomli==1.2.3; extra == "test"
+Requires-Dist: iniconfig==1.1.1; extra == "test"
+Requires-Dist: attrs==22.1.0; extra == "test"
+Requires-Dist: pytest-asyncio==0.21.0; extra == "test"
+Requires-Dist: aiohttp>=3.8.4; extra == "test"
+Requires-Dist: aiofiles>=23.1.0; extra == "test"
+Requires-Dist: requests-kerberos>=0.15.0; extra == "test"
+Provides-Extra: redis
+Requires-Dist: redis>=2.10.5; extra == "redis"
+Provides-Extra: uwsgi
+Requires-Dist: uwsgi>=2.0.0; extra == "uwsgi"
+Provides-Extra: cpphash
+Requires-Dist: mmh3cffi==0.2.1; extra == "cpphash"
+Provides-Extra: asyncio
+Requires-Dist: aiohttp>=3.8.4; extra == "asyncio"
+Requires-Dist: aiofiles>=23.1.0; extra == "asyncio"
+Provides-Extra: kerberos
+Requires-Dist: requests-kerberos>=0.15.0; extra == "kerberos"
+
+# Split Python SDK
+![Build Status](https://github.com/splitio/python-client/actions/workflows/ci.yml/badge.svg?branch=master)
+
+## Overview
+This SDK is designed to work with Split, the platform for controlled rollouts, which serves features to your users via a Split feature flag to manage your complete customer experience.
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/splitsoftware.svg?style=social&label=Follow&maxAge=1529000)](https://twitter.com/intent/follow?screen_name=splitsoftware)
+
+## Compatibility
+This SDK is compatible with **Python 3.7 and higher**.
+
+## Getting started
+Below is a simple example that describes the instantiation and most basic usage of our SDK:
+
+Run `pip install splitio_client`
+
+
+```python
+from splitio import get_factory
+from splitio.exceptions import TimeoutException
+factory = get_factory('YOUR_SDK_TYPE_API_KEY', config=config)
+try:
+    factory.block_until_ready(5) # wait up to 5 seconds
+    split = factory.client()
+    treatment = split.get_treatment('CUSTOMER_ID', 'FEATURE_FLAG_NAME')
+    if treatment == "on":
+        # insert code here to show on treatment
+    elif treatment == "off":
+        # insert code here to show off treatment
+    else:
+        # insert your control treatment code here
+except TimeoutException:
+    # Now the user can choose whether to abort the whole execution, or just keep going
+    # without a ready client, which if configured properly, should become ready at some point.
+    pass
+```
+
+Please refer to [our official docs](https://help.split.io/hc/en-us/articles/360020359652-Python-SDK) to learn about all the functionality provided by our SDK and the configuration options available for tailoring it to your current application setup.
+
+## Submitting issues
+The Split team monitors all issues submitted to this [issue tracker](https://github.com/splitio/python-client/issues). We encourage you to use this issue tracker to submit any bug reports, feedback, and feature enhancements. We'll do our best to respond in a timely manner.
+
+## Contributing
+Please see [Contributors Guide](CONTRIBUTORS-GUIDE.md) to find all you need to submit a Pull Request (PR).
+
+## License
+Licensed under the Apache License, Version 2.0. See: [Apache License](http://www.apache.org/licenses/).
+
+## About Split
+
+Split is the leading Feature Delivery Platform for engineering teams that want to confidently deploy features as fast as they can develop them. Split’s fine-grained management, real-time monitoring, and data-driven experimentation ensure that new features will improve the customer experience without breaking or degrading performance. Companies like Twilio, Salesforce, GoDaddy and WePay trust Split to power their feature delivery.
+
+To learn more about Split, contact hello@split.io, or get started with feature flags for free at https://www.split.io/signup.
+
+Split has built and maintains SDKs for:
+
+* .NET [Github](https://github.com/splitio/dotnet-client) [Docs](https://help.split.io/hc/en-us/articles/360020240172--NET-SDK)
+* Android [Github](https://github.com/splitio/android-client) [Docs](https://help.split.io/hc/en-us/articles/360020343291-Android-SDK)
+* Angular [Github](https://github.com/splitio/angular-sdk-plugin) [Docs](https://help.split.io/hc/en-us/articles/6495326064397-Angular-utilities)
+* GO [Github](https://github.com/splitio/go-client) [Docs](https://help.split.io/hc/en-us/articles/360020093652-Go-SDK)
+* iOS [Github](https://github.com/splitio/ios-client) [Docs](https://help.split.io/hc/en-us/articles/360020401491-iOS-SDK)
+* Java [Github](https://github.com/splitio/java-client) [Docs](https://help.split.io/hc/en-us/articles/360020405151-Java-SDK)
+* JavaScript [Github](https://github.com/splitio/javascript-client) [Docs](https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK)
+* JavaScript for Browser [Github](https://github.com/splitio/javascript-browser-client) [Docs](https://help.split.io/hc/en-us/articles/360058730852-Browser-SDK)
+* Node [Github](https://github.com/splitio/javascript-client) [Docs](https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK)
+* PHP [Github](https://github.com/splitio/php-client) [Docs](https://help.split.io/hc/en-us/articles/360020350372-PHP-SDK)
+* Python [Github](https://github.com/splitio/python-client) [Docs](https://help.split.io/hc/en-us/articles/360020359652-Python-SDK)
+* React [Github](https://github.com/splitio/react-client) [Docs](https://help.split.io/hc/en-us/articles/360038825091-React-SDK)
+* React Native [Github](https://github.com/splitio/react-native-client) [Docs](https://help.split.io/hc/en-us/articles/4406066357901-React-Native-SDK)
+* Redux [Github](https://github.com/splitio/redux-client) [Docs](https://help.split.io/hc/en-us/articles/360038851551-Redux-SDK)
+* Ruby [Github](https://github.com/splitio/ruby-client) [Docs](https://help.split.io/hc/en-us/articles/360020673251-Ruby-SDK)
+
+For a comprehensive list of open source projects visit our [Github page](https://github.com/splitio?utf8=%E2%9C%93&query=%20only%3Apublic%20).
+
+**Learn more about Split:**
+
+Visit [split.io/product](https://www.split.io/product) for an overview of Split, or visit our documentation at [help.split.io](http://help.split.io) for more detailed information.

{splitio_client-10.1.0rc3 → splitio_client-10.2.0}/setup.cfg

@@ -15,7 +15,7 @@ exclude = tests/*
 test = pytest
 
 [tool:pytest]
-addopts = --verbose --cov=splitio --cov-report xml -k HttpClientKerberosTests
+addopts = --verbose --cov=splitio --cov-report xml
 python_classes = *Tests
 
 [build_sphinx]

{splitio_client-10.1.0rc3 → splitio_client-10.2.0}/splitio/client/client.py

@@ -3,7 +3,7 @@ import logging
 
 from splitio.engine.evaluator import Evaluator, CONTROL, EvaluationDataFactory, AsyncEvaluationDataFactory
 from splitio.engine.splitters import Splitter
-from splitio.models.impressions import Impression, Label
+from splitio.models.impressions import Impression, Label, ImpressionDecorated
 from splitio.models.events import Event, EventWrapper
 from splitio.models.telemetry import get_latency_bucket_index, MethodExceptionsAndLatencies
 from splitio.client import input_validator
@@ -22,7 +22,8 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
         'impression': {
             'label': Label.EXCEPTION,
             'change_number': None,
-        }
+        },
+        'impressions_disabled': False
     }
 
     _NON_READY_EVAL_RESULT = {
@@ -31,7 +32,8 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
         'impression': {
             'label': Label.NOT_READY,
             'change_number': None
-        }
+        },
+        'impressions_disabled': False
     }
 
     def __init__(self, factory, recorder, labels_enabled=True):
@@ -116,14 +118,15 @@ class ClientBase(object):  # pylint: disable=too-many-instance-attributes
 
     def _build_impression(self, key, bucketing, feature, result):
         """Build an impression based on evaluation data & it's result."""
-        return Impression(
-                matching_key=key,
+        return ImpressionDecorated(
+                Impression(matching_key=key,
                 feature_name=feature,
                 treatment=result['treatment'],
                 label=result['impression']['label'] if self._labels_enabled else None,
                 change_number=result['impression']['change_number'],
                 bucketing_key=bucketing,
-                time=utctime_ms())
+                time=utctime_ms()),
+                disabled=result['impressions_disabled'])
 
     def _build_impressions(self, key, bucketing, results):
         """Build an impression based on evaluation data & it's result."""
@@ -296,8 +299,8 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
                 result = self._FAILED_EVAL_RESULT
 
         if result['impression']['label'] != Label.SPLIT_NOT_FOUND:
-            impression = self._build_impression(key, bucketing, feature, result)
-            self._record_stats([(impression, attributes)], start, method)
+            impression_decorated = self._build_impression(key, bucketing, feature, result)
+            self._record_stats([(impression_decorated, attributes)], start, method)
 
         return result['treatment'], result['configurations']
 
@@ -571,23 +574,23 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
                 self._telemetry_evaluation_producer.record_exception(method)
                 results = {n: self._FAILED_EVAL_RESULT for n in features}
 
-        imp_attrs = [
+        imp_decorated_attrs = [
             (i, attributes) for i in self._build_impressions(key, bucketing, results)
-            if i.label != Label.SPLIT_NOT_FOUND
+            if i.Impression.label != Label.SPLIT_NOT_FOUND
         ]
-        self._record_stats(imp_attrs, start, method)
+        self._record_stats(imp_decorated_attrs, start, method)
 
         return {
             feature: (results[feature]['treatment'], results[feature]['configurations'])
             for feature in results
         }
 
-    def _record_stats(self, impressions, start, operation):
+    def _record_stats(self, impressions_decorated, start, operation):
         """
         Record impressions.
 
-        :param impressions: Generated impressions
-        :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
+        :param impressions_decorated: Generated impressions
+        :type impressions_decorated: list[tuple[splitio.models.impression.ImpressionDecorated, dict]]
 
         :param start: timestamp when get_treatment or get_treatments was called
         :type start: int
@@ -596,7 +599,7 @@ class Client(ClientBase):  # pylint: disable=too-many-instance-attributes
         :type operation: str
         """
         end = get_current_epoch_time_ms()
-        self._recorder.record_treatment_stats(impressions, get_latency_bucket_index(end - start),
+        self._recorder.record_treatment_stats(impressions_decorated, get_latency_bucket_index(end - start),
                                               operation, 'get_' + operation.value)
 
     def track(self, key, traffic_type, event_type, value=None, properties=None):
@@ -763,8 +766,8 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
                 result = self._FAILED_EVAL_RESULT
 
         if result['impression']['label'] != Label.SPLIT_NOT_FOUND:
-            impression = self._build_impression(key, bucketing, feature, result)
-            await self._record_stats([(impression, attributes)], start, method)
+            impression_decorated = self._build_impression(key, bucketing, feature, result)
+            await self._record_stats([(impression_decorated, attributes)], start, method)
         return result['treatment'], result['configurations']
 
     async def get_treatments(self, key, feature_flag_names, attributes=None):
@@ -960,23 +963,23 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
                 await self._telemetry_evaluation_producer.record_exception(method)
                 results = {n: self._FAILED_EVAL_RESULT for n in features}
 
-        imp_attrs = [
+        imp_decorated_attrs = [
             (i, attributes) for i in self._build_impressions(key, bucketing, results)
-            if i.label != Label.SPLIT_NOT_FOUND
+            if i.Impression.label != Label.SPLIT_NOT_FOUND
         ]
-        await self._record_stats(imp_attrs, start, method)
+        await self._record_stats(imp_decorated_attrs, start, method)
 
         return {
             feature: (res['treatment'], res['configurations'])
             for feature, res in results.items()
         }
 
-    async def _record_stats(self, impressions, start, operation):
+    async def _record_stats(self, impressions_decorated, start, operation):
         """
         Record impressions for async calls
 
-        :param impressions: Generated impressions
-        :type impressions: list[tuple[splitio.models.impression.Impression, dict]]
+        :param impressions_decorated: Generated impressions decorated
+        :type impressions_decorated: list[tuple[splitio.models.impression.Impression, dict]]
 
         :param start: timestamp when get_treatment or get_treatments was called
         :type start: int
@@ -985,7 +988,7 @@ class ClientAsync(ClientBase):  # pylint: disable=too-many-instance-attributes
         :type operation: str
         """
         end = get_current_epoch_time_ms()
-        await self._recorder.record_treatment_stats(impressions, get_latency_bucket_index(end - start),
+        await self._recorder.record_treatment_stats(impressions_decorated, get_latency_bucket_index(end - start),
                                               operation, 'get_' + operation.value)
 
     async def track(self, key, traffic_type, event_type, value=None, properties=None):

{splitio_client-10.1.0rc3 → splitio_client-10.2.0}/splitio/client/factory.py

@@ -13,7 +13,7 @@ from splitio.client import util
 from splitio.client.listener import ImpressionListenerWrapper, ImpressionListenerWrapperAsync
 from splitio.engine.impressions.impressions import Manager as ImpressionsManager
 from splitio.engine.impressions import set_classes, set_classes_async
-from splitio.engine.impressions.strategies import StrategyDebugMode
+from splitio.engine.impressions.strategies import StrategyDebugMode, StrategyNoneMode
 from splitio.engine.telemetry import TelemetryStorageProducer, TelemetryStorageConsumer, \
     TelemetryStorageProducerAsync, TelemetryStorageConsumerAsync
 from splitio.engine.impressions.manager import Counter as ImpressionsCounter
@@ -553,10 +553,10 @@ def _build_in_memory_factory(api_key, cfg, sdk_url=None, events_url=None,  # pyl
     unique_keys_tracker = UniqueKeysTracker(_UNIQUE_KEYS_CACHE_SIZE)
     unique_keys_synchronizer, clear_filter_sync, unique_keys_task, \
     clear_filter_task, impressions_count_sync, impressions_count_task, \
-    imp_strategy = set_classes('MEMORY', cfg['impressionsMode'], apis, imp_counter, unique_keys_tracker)
+    imp_strategy, none_strategy = set_classes('MEMORY', cfg['impressionsMode'], apis, imp_counter, unique_keys_tracker)
 
     imp_manager = ImpressionsManager(
-        imp_strategy, telemetry_runtime_producer)
+        imp_strategy, none_strategy, telemetry_runtime_producer)
 
     synchronizers = SplitSynchronizers(
         SplitSynchronizer(apis['splits'], storages['splits']),
@@ -681,10 +681,10 @@ async def _build_in_memory_factory_async(api_key, cfg, sdk_url=None, events_url=
     unique_keys_tracker = UniqueKeysTrackerAsync(_UNIQUE_KEYS_CACHE_SIZE)
     unique_keys_synchronizer, clear_filter_sync, unique_keys_task, \
     clear_filter_task, impressions_count_sync, impressions_count_task, \
-    imp_strategy = set_classes_async('MEMORY', cfg['impressionsMode'], apis, imp_counter, unique_keys_tracker)
+    imp_strategy, none_strategy = set_classes_async('MEMORY', cfg['impressionsMode'], apis, imp_counter, unique_keys_tracker)
 
     imp_manager = ImpressionsManager(
-        imp_strategy, telemetry_runtime_producer)
+        imp_strategy, none_strategy, telemetry_runtime_producer)
 
     synchronizers = SplitSynchronizers(
         SplitSynchronizerAsync(apis['splits'], storages['splits']),
@@ -775,10 +775,10 @@ def _build_redis_factory(api_key, cfg):
     unique_keys_tracker = UniqueKeysTracker(_UNIQUE_KEYS_CACHE_SIZE)
     unique_keys_synchronizer, clear_filter_sync, unique_keys_task, \
     clear_filter_task, impressions_count_sync, impressions_count_task, \
-    imp_strategy = set_classes('REDIS', cfg['impressionsMode'], redis_adapter, imp_counter, unique_keys_tracker)
+    imp_strategy, none_strategy = set_classes('REDIS', cfg['impressionsMode'], redis_adapter, imp_counter, unique_keys_tracker)
 
     imp_manager = ImpressionsManager(
-        imp_strategy,
+        imp_strategy, none_strategy,
         telemetry_runtime_producer)
 
     synchronizers = SplitSynchronizers(None, None, None, None,
@@ -858,10 +858,10 @@ async def _build_redis_factory_async(api_key, cfg):
     unique_keys_tracker = UniqueKeysTrackerAsync(_UNIQUE_KEYS_CACHE_SIZE)
     unique_keys_synchronizer, clear_filter_sync, unique_keys_task, \
     clear_filter_task, impressions_count_sync, impressions_count_task, \
-    imp_strategy = set_classes_async('REDIS', cfg['impressionsMode'], redis_adapter, imp_counter, unique_keys_tracker)
+    imp_strategy, none_strategy = set_classes_async('REDIS', cfg['impressionsMode'], redis_adapter, imp_counter, unique_keys_tracker)
 
     imp_manager = ImpressionsManager(
-        imp_strategy,
+        imp_strategy, none_strategy,
         telemetry_runtime_producer)
 
     synchronizers = SplitSynchronizers(None, None, None, None,
@@ -936,10 +936,10 @@ def _build_pluggable_factory(api_key, cfg):
     unique_keys_tracker = UniqueKeysTracker(_UNIQUE_KEYS_CACHE_SIZE)
     unique_keys_synchronizer, clear_filter_sync, unique_keys_task, \
     clear_filter_task, impressions_count_sync, impressions_count_task, \
-    imp_strategy = set_classes('PLUGGABLE', cfg['impressionsMode'], pluggable_adapter, imp_counter, unique_keys_tracker, storage_prefix)
+    imp_strategy, none_strategy = set_classes('PLUGGABLE', cfg['impressionsMode'], pluggable_adapter, imp_counter, unique_keys_tracker, storage_prefix)
 
     imp_manager = ImpressionsManager(
-        imp_strategy,
+        imp_strategy, none_strategy,
         telemetry_runtime_producer)
 
     synchronizers = SplitSynchronizers(None, None, None, None,
@@ -1017,10 +1017,10 @@ async def _build_pluggable_factory_async(api_key, cfg):
     unique_keys_tracker = UniqueKeysTrackerAsync(_UNIQUE_KEYS_CACHE_SIZE)
     unique_keys_synchronizer, clear_filter_sync, unique_keys_task, \
     clear_filter_task, impressions_count_sync, impressions_count_task, \
-    imp_strategy = set_classes_async('PLUGGABLE', cfg['impressionsMode'], pluggable_adapter, imp_counter, unique_keys_tracker, storage_prefix)
+    imp_strategy, none_strategy = set_classes_async('PLUGGABLE', cfg['impressionsMode'], pluggable_adapter, imp_counter, unique_keys_tracker, storage_prefix)
 
     imp_manager = ImpressionsManager(
-        imp_strategy,
+        imp_strategy, none_strategy,
         telemetry_runtime_producer)
 
     synchronizers = SplitSynchronizers(None, None, None, None,
@@ -1123,7 +1123,7 @@ def _build_localhost_factory(cfg):
         manager.start()
 
     recorder = StandardRecorder(
-        ImpressionsManager(StrategyDebugMode(), telemetry_runtime_producer),
+        ImpressionsManager(StrategyDebugMode(), StrategyNoneMode(), telemetry_runtime_producer),
         storages['events'],
         storages['impressions'],
         telemetry_evaluation_producer,
@@ -1192,7 +1192,7 @@ async def _build_localhost_factory_async(cfg):
         await manager.start()
 
     recorder = StandardRecorderAsync(
-        ImpressionsManager(StrategyDebugMode(), telemetry_runtime_producer),
+        ImpressionsManager(StrategyDebugMode(), StrategyNoneMode(), telemetry_runtime_producer),
         storages['events'],
         storages['impressions'],
         telemetry_evaluation_producer,

{splitio_client-10.1.0rc3 → splitio_client-10.2.0}/splitio/engine/evaluator.py

@@ -67,7 +67,8 @@ class Evaluator(object):  # pylint: disable=too-few-public-methods
             'impression': {
                 'label': label,
                 'change_number': _change_number
-            }
+            },
+            'impressions_disabled': feature.impressions_disabled if feature else None
         }
 
     def _treatment_for_flag(self, flag, key, bucketing, attributes, ctx):

{splitio_client-10.1.0rc3 → splitio_client-10.2.0}/splitio/engine/impressions/__init__.py

@@ -53,24 +53,24 @@ def set_classes(storage_mode, impressions_mode, api_adapter, imp_counter, unique
         api_impressions_adapter = api_adapter['impressions']
         sender_adapter = InMemorySenderAdapter(api_telemetry_adapter)
 
+    none_strategy = StrategyNoneMode()
+    unique_keys_synchronizer = UniqueKeysSynchronizer(sender_adapter, unique_keys_tracker)
+    unique_keys_task = UniqueKeysSyncTask(unique_keys_synchronizer.send_all)
+    clear_filter_sync = ClearFilterSynchronizer(unique_keys_tracker)
+    impressions_count_sync = ImpressionsCountSynchronizer(api_impressions_adapter, imp_counter)
+    impressions_count_task = ImpressionsCountSyncTask(impressions_count_sync.synchronize_counters)
+    clear_filter_task = ClearFilterSyncTask(clear_filter_sync.clear_all)
+    unique_keys_tracker.set_queue_full_hook(unique_keys_task.flush)
+
     if impressions_mode == ImpressionsMode.NONE:
         imp_strategy = StrategyNoneMode()
-        unique_keys_synchronizer = UniqueKeysSynchronizer(sender_adapter, unique_keys_tracker)
-        unique_keys_task = UniqueKeysSyncTask(unique_keys_synchronizer.send_all)
-        clear_filter_sync = ClearFilterSynchronizer(unique_keys_tracker)
-        impressions_count_sync = ImpressionsCountSynchronizer(api_impressions_adapter, imp_counter)
-        impressions_count_task = ImpressionsCountSyncTask(impressions_count_sync.synchronize_counters)
-        clear_filter_task = ClearFilterSyncTask(clear_filter_sync.clear_all)
-        unique_keys_tracker.set_queue_full_hook(unique_keys_task.flush)
     elif impressions_mode == ImpressionsMode.DEBUG:
         imp_strategy = StrategyDebugMode()
     else:
         imp_strategy = StrategyOptimizedMode()
-        impressions_count_sync = ImpressionsCountSynchronizer(api_impressions_adapter, imp_counter)
-        impressions_count_task = ImpressionsCountSyncTask(impressions_count_sync.synchronize_counters)
 
     return unique_keys_synchronizer, clear_filter_sync, unique_keys_task, clear_filter_task, \
-            impressions_count_sync, impressions_count_task, imp_strategy
+            impressions_count_sync, impressions_count_task, imp_strategy, none_strategy
 
 def set_classes_async(storage_mode, impressions_mode, api_adapter, imp_counter, unique_keys_tracker, prefix=None):
     """
@@ -118,21 +118,21 @@ def set_classes_async(storage_mode, impressions_mode, api_adapter, imp_counter,
         api_impressions_adapter = api_adapter['impressions']
         sender_adapter = InMemorySenderAdapterAsync(api_telemetry_adapter)
 
+    none_strategy = StrategyNoneMode()
+    unique_keys_synchronizer = UniqueKeysSynchronizerAsync(sender_adapter, unique_keys_tracker)
+    unique_keys_task = UniqueKeysSyncTaskAsync(unique_keys_synchronizer.send_all)
+    clear_filter_sync = ClearFilterSynchronizerAsync(unique_keys_tracker)
+    impressions_count_sync = ImpressionsCountSynchronizerAsync(api_impressions_adapter, imp_counter)
+    impressions_count_task = ImpressionsCountSyncTaskAsync(impressions_count_sync.synchronize_counters)
+    clear_filter_task = ClearFilterSyncTaskAsync(clear_filter_sync.clear_all)
+    unique_keys_tracker.set_queue_full_hook(unique_keys_task.flush)
+
     if impressions_mode == ImpressionsMode.NONE:
         imp_strategy = StrategyNoneMode()
-        unique_keys_synchronizer = UniqueKeysSynchronizerAsync(sender_adapter, unique_keys_tracker)
-        unique_keys_task = UniqueKeysSyncTaskAsync(unique_keys_synchronizer.send_all)
-        clear_filter_sync = ClearFilterSynchronizerAsync(unique_keys_tracker)
-        impressions_count_sync = ImpressionsCountSynchronizerAsync(api_impressions_adapter, imp_counter)
-        impressions_count_task = ImpressionsCountSyncTaskAsync(impressions_count_sync.synchronize_counters)
-        clear_filter_task = ClearFilterSyncTaskAsync(clear_filter_sync.clear_all)
-        unique_keys_tracker.set_queue_full_hook(unique_keys_task.flush)
     elif impressions_mode == ImpressionsMode.DEBUG:
         imp_strategy = StrategyDebugMode()
     else:
         imp_strategy = StrategyOptimizedMode()
-        impressions_count_sync = ImpressionsCountSynchronizerAsync(api_impressions_adapter, imp_counter)
-        impressions_count_task = ImpressionsCountSyncTaskAsync(impressions_count_sync.synchronize_counters)
 
     return unique_keys_synchronizer, clear_filter_sync, unique_keys_task, clear_filter_task, \
-            impressions_count_sync, impressions_count_task, imp_strategy
+            impressions_count_sync, impressions_count_task, imp_strategy, none_strategy

splitio_client-10.2.0/splitio/engine/impressions/impressions.py

@@ -0,0 +1,55 @@
+"""Split evaluator module."""
+from enum import Enum
+
+class ImpressionsMode(Enum):
+    """Impressions tracking mode."""
+
+    OPTIMIZED = "OPTIMIZED"
+    DEBUG = "DEBUG"
+    NONE = "NONE"
+
+class Manager(object):  # pylint:disable=too-few-public-methods
+    """Impression manager."""
+
+    def __init__(self, strategy, none_strategy, telemetry_runtime_producer):
+        """
+        Construct a manger to track and forward impressions to the queue.
+
+        :param listener: Optional impressions listener that will capture all seen impressions.
+        :type listener: splitio.client.listener.ImpressionListenerWrapper
+
+        :param strategy: Impressions stragetgy instance
+        :type strategy: (BaseStrategy)
+        """
+
+        self._strategy = strategy
+        self._none_strategy = none_strategy
+        self._telemetry_runtime_producer = telemetry_runtime_producer
+
+    def process_impressions(self, impressions_decorated):
+        """
+        Process impressions.
+
+        Impressions are analyzed to see if they've been seen before and counted.
+
+        :param impressions_decorated: List of impression objects with attributes
+        :type impressions_decorated: list[tuple[splitio.models.impression.ImpressionDecorated, dict]]
+
+        :return: processed and deduped impressions.
+        :rtype: tuple(list[tuple[splitio.models.impression.Impression, dict]], list(int))
+        """
+        for_listener_all = []
+        for_log_all = []
+        for_counter_all = []
+        for_unique_keys_tracker_all = []
+        for impression_decorated, att in impressions_decorated:
+            if impression_decorated.disabled:
+                for_log, for_listener, for_counter, for_unique_keys_tracker = self._none_strategy.process_impressions([(impression_decorated.Impression, att)])
+            else:
+                for_log, for_listener, for_counter, for_unique_keys_tracker = self._strategy.process_impressions([(impression_decorated.Impression, att)])
+            for_listener_all.extend(for_listener)
+            for_log_all.extend(for_log)
+            for_counter_all.extend(for_counter)
+            for_unique_keys_tracker_all.extend(for_unique_keys_tracker)
+
+        return for_log_all, len(impressions_decorated) - len(for_log_all), for_listener_all, for_counter_all, for_unique_keys_tracker_all

{splitio_client-10.1.0rc3 → splitio_client-10.2.0}/splitio/models/impressions.py

@@ -16,6 +16,14 @@ Impression = namedtuple(
     ]
 )
 
+ImpressionDecorated = namedtuple(
+    'ImpressionDecorated',
+    [
+        'Impression',
+        'disabled'
+    ]
+)
+
 # pre-python3.7 hack to make previous_time optional
 Impression.__new__.__defaults__ = (None,)
 

{splitio_client-10.1.0rc3 → splitio_client-10.2.0}/splitio/models/splits.py

@@ -10,7 +10,7 @@ _LOGGER = logging.getLogger(__name__)
 
 SplitView = namedtuple(
     'SplitView',
-    ['name', 'traffic_type', 'killed', 'treatments', 'change_number', 'configs', 'default_treatment', 'sets']
+    ['name', 'traffic_type', 'killed', 'treatments', 'change_number', 'configs', 'default_treatment', 'sets', 'impressions_disabled']
 )
 
 _DEFAULT_CONDITIONS_TEMPLATE =   {
@@ -73,7 +73,8 @@ class Split(object):  # pylint: disable=too-many-instance-attributes
             traffic_allocation=None,
             traffic_allocation_seed=None,
             configurations=None,
-            sets=None
+            sets=None,
+            impressions_disabled=None
     ):
         """
         Class constructor.
@@ -96,6 +97,8 @@ class Split(object):  # pylint: disable=too-many-instance-attributes
         :type traffic_allocation_seed: int
         :pram sets: list of flag sets
         :type sets: list
+        :pram impressions_disabled: track impressions flag
+        :type impressions_disabled: boolean
         """
         self._name = name
         self._seed = seed
@@ -125,6 +128,7 @@ class Split(object):  # pylint: disable=too-many-instance-attributes
 
         self._configurations = configurations
         self._sets = set(sets) if sets is not None else set()
+        self._impressions_disabled = impressions_disabled if impressions_disabled is not None else False
 
     @property
     def name(self):
@@ -186,6 +190,11 @@ class Split(object):  # pylint: disable=too-many-instance-attributes
         """Return the flag sets of the split."""
         return self._sets
 
+    @property
+    def impressions_disabled(self):
+        """Return impressions_disabled of the split."""
+        return self._impressions_disabled
+
     def get_configurations_for(self, treatment):
         """Return the mapping of treatments to configurations."""
         return self._configurations.get(treatment) if self._configurations else None
@@ -214,7 +223,8 @@ class Split(object):  # pylint: disable=too-many-instance-attributes
             'algo': self.algo.value,
             'conditions': [c.to_json() for c in self.conditions],
             'configurations': self._configurations,
-            'sets': list(self._sets)
+            'sets': list(self._sets),
+            'impressionsDisabled': self._impressions_disabled
         }
 
     def to_split_view(self):
@@ -232,7 +242,8 @@ class Split(object):  # pylint: disable=too-many-instance-attributes
             self.change_number,
             self._configurations if self._configurations is not None else {},
             self._default_treatment,
-            list(self._sets) if self._sets is not None else []
+            list(self._sets) if self._sets is not None else [],
+            self._impressions_disabled
         )
 
     def local_kill(self, default_treatment, change_number):
@@ -288,5 +299,6 @@ def from_raw(raw_split):
         traffic_allocation=raw_split.get('trafficAllocation'),
         traffic_allocation_seed=raw_split.get('trafficAllocationSeed'),
         configurations=raw_split.get('configurations'),
-        sets=set(raw_split.get('sets')) if raw_split.get('sets') is not None else []
+        sets=set(raw_split.get('sets')) if raw_split.get('sets') is not None else [],
+        impressions_disabled=raw_split.get('impressionsDisabled') if raw_split.get('impressionsDisabled') is not None else False
     )