Merge branch 'task/deprecatePython2' of github.com:splitio/python-client into task/removingp2

Author: Matias Melograno

splitio/models/grammar/condition.py

@@ -85,6 +85,14 @@ def get_segment_names(self):
             if isinstance(matcher, matchers.UserDefinedSegmentMatcher)
         ]
 
+    def __str__(self):
+        """Return the string representation of the condition."""
+        return '{matcher} then split {parts}'.format(
+            matcher=self._matchers, parts=','.join(
+                '{size}:{treatment}'.format(size=partition.size,
+                                            treatment=partition.treatment)
+                for partition in self._partitions))
+
     def to_json(self):
         """Return the JSON representation of this condition."""
         return {

splitio/models/grammar/matchers/keys.py

@@ -30,6 +30,10 @@ def _match(self, key, attributes=None, context=None):
         """
         return key is not None
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'in segment all'
+
     def _add_matcher_specific_properties_to_json(self):
         """Add matcher specific properties to base dict before returning it."""
         return {}
@@ -77,3 +81,9 @@ def _add_matcher_specific_properties_to_json(self):
                 'segmentName': self._segment_name
             }
         }
+
+    def __str__(self):
+        """Return string Representation."""
+        return 'in segment {segment_name}'.format(
+            segment_name=self._segment_name
+        )

splitio/models/grammar/matchers/numeric.py

@@ -108,6 +108,10 @@ def _match(self, key, attributes=None, context=None):
             return False
         return self._lower <= self.input_parsers[self._data_type](matching_data) <= self._upper
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'between {start} and {end}'.format(start=self._lower, end=self._upper)
+
     def _add_matcher_specific_properties_to_json(self):
         """Return BetweenMatcher specific properties."""
         return {

splitio/models/grammar/matchers/sets.py

@@ -45,6 +45,12 @@ def _add_matcher_specific_properties_to_json(self):
             }
         }
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'contains all of the following set: [{whitelist}]'.format(
+            whitelist=','.join('"{}"'.format(item) for item in self._whitelist)
+        )
+
 
 class ContainsAnyOfSetMatcher(Matcher):
     """Matcher that returns true if the intersection of both sets is not empty."""
@@ -88,6 +94,12 @@ def _add_matcher_specific_properties_to_json(self):
             }
         }
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'contains on of the following se: [{whitelist}]'.format(
+            whitelist=','.join('"{}"'.format(item) for item in self._whitelist)
+        )
+
 
 class EqualToSetMatcher(Matcher):
     """Matcher that returns true if the set provided by the user is equal to the matcher's one."""
@@ -131,6 +143,12 @@ def _add_matcher_specific_properties_to_json(self):
             }
         }
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'equals the following set: [{whitelist}]'.format(
+            whitelist=','.join('"{}"'.format(item) for item in self._whitelist)
+        )
+
 
 class PartOfSetMatcher(Matcher):
     """a."""
@@ -174,3 +192,9 @@ def _add_matcher_specific_properties_to_json(self):
                 'whitelist': list(self._whitelist)
             }
         }
+
+    def __str__(self):
+        """Return string Representation."""
+        return 'is a subset of the following set: [{whitelist}]'.format(
+            whitelist=','.join('"{}"'.format(item) for item in self._whitelist)
+        )

splitio/models/grammar/matchers/string.py

@@ -78,6 +78,12 @@ def _add_matcher_specific_properties_to_json(self):
             }
         }
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'in whitelist [{whitelist}]'.format(
+            whitelist=','.join('"{}"'.format(item) for item in self._whitelist)
+        )
+
 
 class StartsWithMatcher(Matcher):
     """Matcher that returns true if the key is a prefix of the stored value."""
@@ -119,6 +125,12 @@ def _add_matcher_specific_properties_to_json(self):
             }
         }
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'has one of the following prefixes [{whitelist}]'.format(
+            whitelist=','.join('"{}"'.format(item) for item in self._whitelist)
+        )
+
 
 class EndsWithMatcher(Matcher):
     """Matcher that returns true if the key ends with the suffix stored in matcher data."""
@@ -160,6 +172,12 @@ def _add_matcher_specific_properties_to_json(self):
             }
         }
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'has one of the following suffixes [{whitelist}]'.format(
+            whitelist=','.join('"{}"'.format(item) for item in self._whitelist)
+        )
+
 
 class ContainsStringMatcher(Matcher):
     """Matcher that returns true if the input key is part of the string in matcher data."""
@@ -201,6 +219,12 @@ def _add_matcher_specific_properties_to_json(self):
             }
         }
 
+    def __str__(self):
+        """Return string Representation."""
+        return 'contains one of the following string: [{whitelist}]'.format(
+            whitelist=','.join('"{}"'.format(item) for item in self._whitelist)
+        )
+
 
 class RegexMatcher(Matcher):
     """Matcher that returns true if the user input matches the regex stored in the matcher."""

splitio/models/grammar/partitions.py

@@ -36,6 +36,11 @@ def to_json(self):
             'size': self._size
         }
 
+    def __str__(self):
+        """Return string representation of a partition."""
+        return '{size}%:{treatment}'.format(size=self._size,
+                                            treatment=self._treatment)
+
 
 def from_raw(raw_partition):
     """

splitio/models/splits.py

@@ -205,6 +205,16 @@ def local_kill(self, default_treatment, change_number):
         self._change_number = change_number
         self._killed = True
 
+    def __str__(self):
+        """Return string representation."""
+        return 'name: {name}, seed: {seed}, killed: {killed}, ' \
+               'default treatment: {default_treatment}, ' \
+               'conditions: {conditions}'.format(
+                   name=self._name, seed=self._seed, killed=self._killed,
+                   default_treatment=self._default_treatment,
+                   conditions=','.join(map(str, self._conditions))
+               )
+
 
 def from_raw(raw_split):
     """