splitio-client 9.6.1__tar.gz → 9.7.0__tar.gz

splitio_client-9.7.0/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright © 2024 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-9.6.1 → splitio_client-9.7.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: splitio_client
-Version: 9.6.1
+Version: 9.7.0
 Summary: Split.io Python Client
 Home-page: https://github.com/splitio/python-client
 Author: Patricio Echague, Sebastian Arrubia
 Author-email: pato@split.io, sebastian@split.io
 License: Apache License 2.0
-Download-URL: https://github.com/splitio/python-client/tarball/9.6.1
+Download-URL: https://github.com/splitio/python-client/tarball/9.7.0
 Description: UNKNOWN
 Platform: UNKNOWN
 Classifier: Environment :: Console

{splitio_client-9.6.1 → splitio_client-9.7.0}/README.md

@@ -7,7 +7,7 @@ This SDK is designed to work with Split, the platform for controlled rollouts, w
 [![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 and higher**.
+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:

{splitio_client-9.6.1 → splitio_client-9.7.0}/setup.py

@@ -6,21 +6,20 @@ from setuptools import setup, find_packages
 
 TESTS_REQUIRES = [
     'flake8',
-    'pytest==7.0.1',
-    'pytest-mock>=3.5.1',
-    'coverage==6.2',
+    'pytest==7.1.0',
+    'pytest-mock==3.11.1',
+    'coverage==7.2.7',
     'pytest-cov',
-    'importlib-metadata==4.2',
-    'tomli==1.2.3',
-    'iniconfig==1.1.1',
-    'attrs==22.1.0'
+    'importlib-metadata==6.7',
+    'tomli',
+    'iniconfig',
+    'attrs'
 ]
 
 INSTALL_REQUIRES = [
-    'requests>=2.9.1',
-    'pyyaml>=5.4',
+    'requests',
+    'pyyaml',
     'docopt>=0.6.2',
-    'enum34;python_version<"3.4"',
     'bloom-filter2>=2.0.0'
 ]
 

{splitio_client-9.6.1 → splitio_client-9.7.0}/splitio/api/auth.py

@@ -5,6 +5,7 @@ import json
 
 from splitio.api import APIException
 from splitio.api.commons import headers_from_metadata, record_telemetry
+from splitio.spec import SPEC_VERSION
 from splitio.util.time import get_current_epoch_time_ms
 from splitio.api.client import HttpClientException
 from splitio.models.token import from_raw
@@ -43,7 +44,7 @@ class AuthAPI(object):  # pylint: disable=too-few-public-methods
         try:
             response = self._client.get(
                 'auth',
-                '/v2/auth',
+                '/v2/auth?s=' + SPEC_VERSION,
                 self._sdk_key,
                 extra_headers=self._metadata,
             )

{splitio_client-9.6.1 → splitio_client-9.7.0}/splitio/api/commons.py

@@ -1,10 +1,10 @@
 """Commons module."""
 from splitio.util.time import get_current_epoch_time_ms
+from splitio.spec import SPEC_VERSION
 
 _CACHE_CONTROL = 'Cache-Control'
 _CACHE_CONTROL_NO_CACHE = 'no-cache'
 
-
 def headers_from_metadata(sdk_metadata, client_key=None):
     """
     Generate a dict with headers required by data-recording API endpoints.
@@ -57,7 +57,7 @@ def record_telemetry(status_code, elapsed, metric_name, telemetry_runtime_produc
 class FetchOptions(object):
     """Fetch Options object."""
 
-    def __init__(self, cache_control_headers=False, change_number=None, sets=None):
+    def __init__(self, cache_control_headers=False, change_number=None, sets=None, spec=SPEC_VERSION):
         """
         Class constructor.
 
@@ -73,6 +73,7 @@ class FetchOptions(object):
         self._cache_control_headers = cache_control_headers
         self._change_number = change_number
         self._sets = sets
+        self._spec = spec
 
     @property
     def cache_control_headers(self):
@@ -89,6 +90,11 @@ class FetchOptions(object):
         """Return sets."""
         return self._sets
 
+    @property
+    def spec(self):
+        """Return sets."""
+        return self._spec
+
     def __eq__(self, other):
         """Match between other options."""
         if self._cache_control_headers != other._cache_control_headers:
@@ -97,6 +103,8 @@ class FetchOptions(object):
             return False
         if self._sets != other._sets:
             return False
+        if self._spec != other._spec:
+            return False
         return True
 
 
@@ -116,14 +124,15 @@ def build_fetch(change_number, fetch_options, metadata):
     :return: Objects for fetch
     :rtype: dict, dict
     """
-    query = {'since': change_number}
+    query = {'s': fetch_options.spec} if fetch_options.spec is not None else {}
+    query['since'] = change_number
     extra_headers = metadata
     if fetch_options is None:
         return query, extra_headers
     if fetch_options.cache_control_headers:
         extra_headers[_CACHE_CONTROL] = _CACHE_CONTROL_NO_CACHE
-    if fetch_options.change_number is not None:
-        query['till'] = fetch_options.change_number
     if fetch_options.sets is not None:
         query['sets'] = fetch_options.sets
+    if fetch_options.change_number is not None:
+        query['till'] = fetch_options.change_number
     return query, extra_headers

{splitio_client-9.6.1 → splitio_client-9.7.0}/splitio/engine/impressions/adapters.py

@@ -40,6 +40,9 @@ class InMemorySenderAdapter(ImpressionsSenderAdapter):
         :param uniques: unique keys disctionary
         :type uniques: Dictionary {'feature_flag1': set(), 'feature_flag2': set(), .. }
         """
+        if len(uniques) == 0:
+            return
+
         self._telemtry_http_client.record_unique_keys({'keys': self._uniques_formatter(uniques)})
 
     def _uniques_formatter(self, uniques):
@@ -73,6 +76,9 @@ class RedisSenderAdapter(ImpressionsSenderAdapter):
         :param uniques: unique keys disctionary
         :type uniques: Dictionary {'feature_flag1': set(), 'feature_flag2': set(), .. }
         """
+        if len(uniques) == 0:
+            return
+
         bulk_mtks = _uniques_formatter(uniques)
         try:
             inserted = self._redis_client.rpush(_MTK_QUEUE_KEY, *bulk_mtks)
@@ -90,6 +96,9 @@ class RedisSenderAdapter(ImpressionsSenderAdapter):
         :param to_send: unique keys disctionary
         :type to_send: Dictionary {'feature_flag1': set(), 'feature_flag2': set(), .. }
         """
+        if len(to_send) == 0:
+            return
+
         try:
             resulted = 0
             counted = 0
@@ -140,6 +149,9 @@ class PluggableSenderAdapter(ImpressionsSenderAdapter):
         :param uniques: unique keys disctionary
         :type uniques: Dictionary {'feature_flag1': set(), 'feature_flag2': set(), .. }
         """
+        if len(uniques) == 0:
+            return
+
         bulk_mtks = _uniques_formatter(uniques)
         try:
             _LOGGER.debug("record_unique_keys")
@@ -159,6 +171,8 @@ class PluggableSenderAdapter(ImpressionsSenderAdapter):
         :param to_send: unique keys disctionary
         :type to_send: Dictionary {'feature_flag1': set(), 'feature_flag2': set(), .. }
         """
+        if len(to_send) == 0:
+            return
         try:
             resulted = 0
             for pf_count in to_send:

splitio_client-9.7.0/splitio/models/__init__.py

@@ -0,0 +1,6 @@
+class MatcherNotFoundException(Exception):
+    """Exception to raise when a matcher is not found."""
+
+    def __init__(self, custom_message):
+        """Constructor."""
+        Exception.__init__(self, custom_message)

{splitio_client-9.6.1 → splitio_client-9.7.0}/splitio/models/grammar/condition.py

@@ -2,6 +2,7 @@
 
 from enum import Enum
 
+from splitio.models import MatcherNotFoundException
 from splitio.models.grammar import matchers
 from splitio.models.grammar import partitions
 
@@ -124,6 +125,7 @@ def from_raw(raw_condition):
     ]
 
     matcher_objects = [matchers.from_raw(x) for x in raw_condition['matcherGroup']['matchers']]
+
     combiner = _MATCHER_COMBINERS[raw_condition['matcherGroup']['combiner']]
     label = raw_condition.get('label')
 

{splitio_client-9.6.1 → splitio_client-9.7.0}/splitio/models/grammar/matchers/__init__.py

@@ -1,4 +1,5 @@
 """Matchers entrypoint module."""
+from splitio.models import MatcherNotFoundException
 from splitio.models.grammar.matchers.keys import AllKeysMatcher, UserDefinedSegmentMatcher
 from splitio.models.grammar.matchers.numeric import BetweenMatcher, EqualToMatcher, \
     GreaterThanOrEqualMatcher, LessThanOrEqualMatcher
@@ -7,6 +8,8 @@ from splitio.models.grammar.matchers.sets import ContainsAllOfSetMatcher, \
 from splitio.models.grammar.matchers.string import ContainsStringMatcher, \
     EndsWithMatcher, RegexMatcher, StartsWithMatcher, WhitelistMatcher
 from splitio.models.grammar.matchers.misc import BooleanMatcher, DependencyMatcher
+from splitio.models.grammar.matchers.semver import EqualToSemverMatcher, GreaterThanOrEqualToSemverMatcher, LessThanOrEqualToSemverMatcher, \
+        BetweenSemverMatcher, InListSemverMatcher
 
 
 MATCHER_TYPE_ALL_KEYS = 'ALL_KEYS'
@@ -26,6 +29,11 @@ MATCHER_TYPE_CONTAINS_STRING = 'CONTAINS_STRING'
 MATCHER_TYPE_IN_SPLIT_TREATMENT = 'IN_SPLIT_TREATMENT'
 MATCHER_TYPE_EQUAL_TO_BOOLEAN = 'EQUAL_TO_BOOLEAN'
 MATCHER_TYPE_MATCHES_STRING = 'MATCHES_STRING'
+MATCHER_TYPE_EQUAL_TO_SEMVER = 'EQUAL_TO_SEMVER'
+MATCHER_GREATER_THAN_OR_EQUAL_TO_SEMVER = 'GREATER_THAN_OR_EQUAL_TO_SEMVER'
+MATCHER_LESS_THAN_OR_EQUAL_TO_SEMVER = 'LESS_THAN_OR_EQUAL_TO_SEMVER'
+MATCHER_BETWEEN_SEMVER = 'BETWEEN_SEMVER'
+MATCHER_INLIST_SEMVER = 'IN_LIST_SEMVER'
 
 
 _MATCHER_BUILDERS = {
@@ -45,10 +53,14 @@ _MATCHER_BUILDERS = {
     MATCHER_TYPE_CONTAINS_STRING: ContainsStringMatcher,
     MATCHER_TYPE_IN_SPLIT_TREATMENT: DependencyMatcher,
     MATCHER_TYPE_EQUAL_TO_BOOLEAN: BooleanMatcher,
-    MATCHER_TYPE_MATCHES_STRING: RegexMatcher
+    MATCHER_TYPE_MATCHES_STRING: RegexMatcher,
+    MATCHER_TYPE_EQUAL_TO_SEMVER: EqualToSemverMatcher,
+    MATCHER_GREATER_THAN_OR_EQUAL_TO_SEMVER: GreaterThanOrEqualToSemverMatcher,
+    MATCHER_LESS_THAN_OR_EQUAL_TO_SEMVER: LessThanOrEqualToSemverMatcher,
+    MATCHER_BETWEEN_SEMVER: BetweenSemverMatcher,
+    MATCHER_INLIST_SEMVER: InListSemverMatcher
 }
 
-
 def from_raw(raw_matcher):
     """
     Parse a condition from a JSON portion of splitChanges.
@@ -63,5 +75,5 @@ def from_raw(raw_matcher):
     try:
         builder = _MATCHER_BUILDERS[matcher_type]
     except KeyError:
-        raise ValueError('Invalid matcher type %s' % matcher_type)
+        raise MatcherNotFoundException('Invalid matcher type %s' % matcher_type)
     return builder(raw_matcher)

splitio_client-9.7.0/splitio/models/grammar/matchers/semver.py

@@ -0,0 +1,260 @@
+"""Semver matcher classes."""
+import logging
+
+from splitio.models.grammar.matchers.base import Matcher
+from splitio.models.grammar.matchers.string import Sanitizer
+from splitio.models.grammar.matchers.utils.utils import build_semver_or_none
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class EqualToSemverMatcher(Matcher):
+    """A matcher for Semver equal to."""
+
+    def _build(self, raw_matcher):
+        """
+        Build an EqualToSemverMatcher.
+
+        :param raw_matcher: raw matcher as fetched from splitChanges response.
+        :type raw_matcher: dict
+        """
+        self._data = raw_matcher.get('stringMatcherData')
+        self._semver = build_semver_or_none(raw_matcher.get('stringMatcherData'))
+
+    def _match(self, key, attributes=None, context=None):
+        """
+        Evaluate user input against a matcher and return whether the match is successful.
+
+        :param key: User key.
+        :type key: str.
+        :param attributes: Custom user attributes.
+        :type attributes: dict.
+        :param context: Evaluation context
+        :type context: dict
+
+        :returns: Wheter the match is successful.
+        :rtype: bool
+        """
+        if self._semver is None:
+            _LOGGER.error("stringMatcherData is required for EQUAL_TO_SEMVER matcher type")
+            return False
+
+        matching_data = Sanitizer.ensure_string(self._get_matcher_input(key, attributes))
+        if matching_data is None:
+            return False
+
+        matching_semver = build_semver_or_none(matching_data)
+        if matching_semver is None:
+            return False
+
+        return self._semver.version == matching_semver.version
+
+    def __str__(self):
+        """Return string Representation."""
+        return f'equal semver {self._data}'
+
+    def _add_matcher_specific_properties_to_json(self):
+        """Add matcher specific properties to base dict before returning it."""
+        return {'matcherType': 'EQUAL_TO_SEMVER', 'stringMatcherData': self._data}
+
+class GreaterThanOrEqualToSemverMatcher(Matcher):
+    """A matcher for Semver greater than or equal to."""
+
+    def _build(self, raw_matcher):
+        """
+        Build a GreaterThanOrEqualToSemverMatcher.
+
+        :param raw_matcher: raw matcher as fetched from splitChanges response.
+        :type raw_matcher: dict
+        """
+        self._data = raw_matcher.get('stringMatcherData')
+        self._semver = build_semver_or_none(raw_matcher.get('stringMatcherData'))
+
+    def _match(self, key, attributes=None, context=None):
+        """
+        Evaluate user input against a matcher and return whether the match is successful.
+
+        :param key: User key.
+        :type key: str.
+        :param attributes: Custom user attributes.
+        :type attributes: dict.
+        :param context: Evaluation context
+        :type context: dict
+
+        :returns: Wheter the match is successful.
+        :rtype: bool
+        """
+        if self._semver is None:
+            _LOGGER.error("stringMatcherData is required for GREATER_THAN_OR_EQUAL_TO_SEMVER matcher type")
+            return False
+
+        matching_data = Sanitizer.ensure_string(self._get_matcher_input(key, attributes))
+        if matching_data is None:
+            return False
+
+        matching_semver = build_semver_or_none(matching_data)
+        if matching_semver is None:
+            return False
+
+        return matching_semver.compare(self._semver) in [0, 1]
+
+    def __str__(self):
+        """Return string Representation."""
+        return f'greater than or equal to semver {self._data}'
+
+    def _add_matcher_specific_properties_to_json(self):
+        """Add matcher specific properties to base dict before returning it."""
+        return {'matcherType': 'GREATER_THAN_OR_EQUAL_TO_SEMVER', 'stringMatcherData': self._data}
+
+
+class LessThanOrEqualToSemverMatcher(Matcher):
+    """A matcher for Semver less than or equal to."""
+
+    def _build(self, raw_matcher):
+        """
+        Build a LessThanOrEqualToSemverMatcher.
+
+        :param raw_matcher: raw matcher as fetched from splitChanges response.
+        :type raw_matcher: dict
+        """
+        self._data = raw_matcher.get('stringMatcherData')
+        self._semver = build_semver_or_none(raw_matcher.get('stringMatcherData'))
+
+    def _match(self, key, attributes=None, context=None):
+        """
+        Evaluate user input against a matcher and return whether the match is successful.
+
+        :param key: User key.
+        :type key: str.
+        :param attributes: Custom user attributes.
+        :type attributes: dict.
+        :param context: Evaluation context
+        :type context: dict
+
+        :returns: Wheter the match is successful.
+        :rtype: bool
+        """
+        if self._semver is None:
+            _LOGGER.error("stringMatcherData is required for LESS_THAN_OR_EQUAL_TO_SEMVER matcher type")
+            return False
+
+        matching_data = Sanitizer.ensure_string(self._get_matcher_input(key, attributes))
+        if matching_data is None:
+            return False
+
+        matching_semver = build_semver_or_none(matching_data)
+        if matching_semver is None:
+            return False
+
+        return matching_semver.compare(self._semver) in [0, -1]
+
+    def __str__(self):
+        """Return string Representation."""
+        return f'less than or equal to semver {self._data}'
+
+    def _add_matcher_specific_properties_to_json(self):
+        """Add matcher specific properties to base dict before returning it."""
+        return {'matcherType': 'LESS_THAN_OR_EQUAL_TO_SEMVER', 'stringMatcherData': self._data}
+
+
+class BetweenSemverMatcher(Matcher):
+    """A matcher for Semver between."""
+
+    def _build(self, raw_matcher):
+        """
+        Build a BetweenSemverMatcher.
+
+        :param raw_matcher: raw matcher as fetched from splitChanges response.
+        :type raw_matcher: dict
+        """
+        self._data = raw_matcher.get('betweenStringMatcherData')
+        self._semver_start = build_semver_or_none(self._data['start'])
+        self._semver_end = build_semver_or_none(self._data['end'])
+
+    def _match(self, key, attributes=None, context=None):
+        """
+        Evaluate user input against a matcher and return whether the match is successful.
+
+        :param key: User key.
+        :type key: str.
+        :param attributes: Custom user attributes.
+        :type attributes: dict.
+        :param context: Evaluation context
+        :type context: dict
+
+        :returns: Wheter the match is successful.
+        :rtype: bool
+        """
+        if self._semver_start is None or self._semver_end is None:
+            _LOGGER.error("betweenStringMatcherData is required for BETWEEN_SEMVER matcher type")
+            return False
+
+        matching_data = Sanitizer.ensure_string(self._get_matcher_input(key, attributes))
+        if matching_data is None:
+            return False
+
+        matching_semver = build_semver_or_none(matching_data)
+        if matching_semver is None:
+            return False
+
+        return (self._semver_start.compare(matching_semver) in [0, -1]) and (self._semver_end.compare(matching_semver) in [0, 1])
+
+    def __str__(self):
+        """Return string Representation."""
+        return 'between semver {start} and {end}'.format(start=self._data.get('start'), end=self._data.get('end'))
+
+    def _add_matcher_specific_properties_to_json(self):
+        """Add matcher specific properties to base dict before returning it."""
+        return {'matcherType': 'BETWEEN_SEMVER', 'betweenStringMatcherData': self._data}
+
+
+class InListSemverMatcher(Matcher):
+    """A matcher for Semver in list."""
+
+    def _build(self, raw_matcher):
+        """
+        Build a InListSemverMatcher.
+
+        :param raw_matcher: raw matcher as fetched from splitChanges response.
+        :type raw_matcher: dict
+        """
+        self._data = raw_matcher['whitelistMatcherData']['whitelist']
+        semver_list = [build_semver_or_none(item) for item in self._data if item]
+        self._semver_list = frozenset([item.version for item in semver_list if item])
+
+    def _match(self, key, attributes=None, context=None):
+        """
+        Evaluate user input against a matcher and return whether the match is successful.
+
+        :param key: User key.
+        :type key: str.
+        :param attributes: Custom user attributes.
+        :type attributes: dict.
+        :param context: Evaluation context
+        :type context: dict
+
+        :returns: Wheter the match is successful.
+        :rtype: bool
+        """
+        if self._semver_list is None:
+            _LOGGER.error("whitelistMatcherData is required for IN_LIST_SEMVER matcher type")
+            return False
+
+        matching_data = Sanitizer.ensure_string(self._get_matcher_input(key, attributes))
+        if matching_data is None:
+            return False
+
+        matching_semver = build_semver_or_none(matching_data)
+        if matching_semver is None:
+            return False
+
+        return matching_semver.version in self._semver_list
+
+    def __str__(self):
+        """Return string Representation."""
+        return 'in list semver {data}'.format(data=self._data)
+
+    def _add_matcher_specific_properties_to_json(self):
+        """Add matcher specific properties to base dict before returning it."""
+        return {'matcherType': 'IN_LIST_SEMVER', 'whitelistMatcherData': {'whitelist': self._data}}