added rule based segments

Author: kleinjoshuaa

README.md

@@ -282,6 +282,111 @@ definition= {"treatments":[ {"name":"on"},{"name":"off"}],
 splitDef.submit_change_request(definition, 'UPDATE', 'updating default rule', 'comment', ['user@email.com'], '')
 ```
 
+### Rule-Based Segments
+
+Fetch all Rule-Based Segments:
+
+```python
+ws = client.workspaces.find("Defaults")
+for segment in client.rule_based_segments.list(ws.id):
+    print("\nRule-Based Segment: " + segment.name + ", " + segment.description)
+```
+
+Add new Rule-Based Segment:
+
+```python
+segment_data = {
+    'name': 'advanced_users',
+    'description': 'Users who match advanced criteria',
+    'tags': [{'name': 'important'}]
+}
+rule_segment = ws.add_rule_based_segment(segment_data, "user")
+print(rule_segment.name)
+```
+
+Add Rule-Based Segment to environment:
+
+```python
+ws = client.workspaces.find("Defaults")
+segment = client.rule_based_segments.find("advanced_users", ws.id)
+env = client.environments.find("Production", ws.id)
+segdef = segment.add_to_environment(env.id)
+```
+
+Update Rule-Based Segment definition with rules:
+
+```python
+ws = client.workspaces.find("Defaults")
+env = client.environments.find("Production", ws.id)
+segdef = client.rule_based_segment_definitions.find("advanced_users", env.id, ws.id)
+
+# Define rules that match users with age > 30 and have completed tutorials
+rules_data = {
+    'rules': [
+        {
+            'condition': {
+                'combiner': 'AND',
+                'matchers': [
+                    {
+                        'type': 'GREATER_THAN_OR_EQUAL_TO',
+                        'attribute': 'age',
+                        'number': 30
+                    },
+                    {
+                        'type': 'EQUAL_TO',
+                        'attribute': 'completed_tutorials',
+                        'bool': True
+                    }
+                ]
+            }
+        }
+    ]
+}
+
+# Update the segment definition with the rules
+updated_segdef = segdef.update(rules_data)
+```
+
+Submit a Change request to update a Rule-Based Segment definition:
+
+```python
+ws = client.workspaces.find("Defaults")
+env = client.environments.find("Production", ws.id)
+segdef = client.rule_based_segment_definitions.find("advanced_users", env.id, ws.id)
+
+# New rules for the change request
+rules = [
+    {
+        'condition': {
+            'combiner': 'AND',
+            'matchers': [
+                {
+                    'type': 'GREATER_THAN_OR_EQUAL_NUMBER',
+                    'attribute': 'age',
+                    'number': 25
+                },
+                {
+                    'type': 'BOOLEAN',
+                    'attribute': 'completed_tutorials',
+                    'bool': True
+                }
+            ]
+        }
+    }
+]
+
+# Submit change request
+segdef.submit_change_request(
+    rules=rules,
+    operation_type='UPDATE',
+    title='Lower age threshold to 25',
+    comment='Including more users in advanced segment',
+    approvers=['user@email.com'],
+    rollout_status_id=None,
+    workspace_id=ws.id
+)
+```
+
 List all change requests:
 
 ```python

splitapiclient/microclients/rule_based_segment_definition_microclient.py

@@ -11,7 +11,7 @@ class RuleBasedSegmentDefinitionMicroClient:
     _endpoint = {
         'all_items': {
             'method': 'GET',
-            'url_template': 'rule-based-segments/ws/{workspaceId}/environments/{environmentId}?limit=50&offset={offset}',
+            'url_template': 'rule-based-segments/ws/{workspaceId}/environments/{environmentId}',
             'headers': [{
                 'name': 'Authorization',
                 'template': 'Bearer {value}',
@@ -46,29 +46,17 @@ def list(self, environment_id, workspace_id):
         :returns: list of RuleBasedSegment in environment objects
         :rtype: list(RuleBasedSegmentDefinition)
         '''
-        offset_val = 0
-        final_list = []
-        while True:
-            response = self._http_client.make_request(
-                self._endpoint['all_items'],
-                workspaceId = workspace_id,
-                environmentId = environment_id,
-                offset = offset_val
-            )
-            for item in response:
-                final_list.append(as_dict(item))
-            offset = int(response['offset'])
-            totalCount = int(response['totalCount'])
-            limit = int(response['limit'])
-            if totalCount>(offset+limit):
-                offset_val = offset_val + limit
-                continue
-            else:
-                break
+        response = self._http_client.make_request(
+            self._endpoint['all_items'],
+            workspaceId = workspace_id,
+            environmentId = environment_id
+        )
+        
         segment_definition_list = []
-        for item in final_list:
-            item['environment'] = {'id':environment_id, 'name':''}
-            segment_definition_list.append(RuleBasedSegmentDefinition(item, self._http_client))
+        if isinstance(response, list):
+            for item in response:
+                item['environment'] = {'id':environment_id, 'name':''}
+                segment_definition_list.append(RuleBasedSegmentDefinition(item, self._http_client))
         return segment_definition_list
 
     def find(self, segment_name, environment_id, workspace_id):

splitapiclient/microclients/rule_based_segment_microclient.py

@@ -80,25 +80,18 @@ def list(self, workspace_id):
         :returns: list of RuleBasedSegment objects
         :rtype: list(RuleBasedSegment)
         '''
-        offset_val = 0
-        final_list = []
-        while True:
-            response = self._http_client.make_request(
-                self._endpoint['all_items'],
-                workspaceId = workspace_id,
-                offset = offset_val
-            )
-            for item in response:
-                final_list.append(as_dict(item))
-            offset = int(response['offset'])
-            totalCount = int(response['totalCount'])
-            limit = int(response['limit'])
-            if totalCount>(offset+limit):
-                offset_val = offset_val + limit
-                continue
-            else:
-                break
-        return [RuleBasedSegment(item, self._http_client) for item in final_list]
+        response = self._http_client.make_request(
+            self._endpoint['all_items'],
+            workspaceId = workspace_id
+        )
+        
+        # Check if we have the response
+        if isinstance(response, list):
+            objects = response
+            if not objects:  # If the list is empty, we're done
+                return []
+            return [RuleBasedSegment(item, self._http_client) for item in objects]
+        return []
 
     def find(self, segment_name, workspace_id):
         '''

splitapiclient/resources/rule_based_segment_definition.py

@@ -55,6 +55,9 @@ def __init__(self, data=None, client=None):
         self._environment = data.get('environment')
         self._trafficType = TrafficType(data.get('trafficType')) if 'trafficType' in data else {}
         self._creationTime = data.get('creationTime') if 'creationTime' in data else 0
+        self._excludedKeys = data.get('excludedKeys', [])
+        self._excludedSegments = data.get('excludedSegments', [])
+        self._rules = data.get('rules', [])
 
     @property
     def name(self):
@@ -75,29 +78,45 @@ def tags(self):
     @property
     def creation_time(self):
         return None if self._creationTime==0 else self._creationTime
+        
+    @property
+    def excluded_keys(self):
+        return self._excludedKeys
+        
+    @property
+    def excluded_segments(self):
+        return self._excludedSegments
+        
+    @property
+    def rules(self):
+        return self._rules
 
-    def update(self, data):
+    def update(self, data, apiclient=None):
         '''
         Update RuleBasedSegmentDefinition object.
 
         :param data: dictionary of data to update
+        :param apiclient: If this instance wasn't returned by the client,
+            the ApiClient instance should be passed in order to perform the
+            http call
 
         :returns: RuleBasedSegmentDefinition object
         :rtype: RuleBasedSegmentDefinition
         '''
-        imc = require_client('RuleBasedSegmentDefinition', self._client)
+        imc = require_client('RuleBasedSegmentDefinition', self._client, apiclient)
         return imc.update(self._name, self._environment['id'], self._client._workspace_id, data)
 
-    def submit_change_request(self, rules, operation_type, title, comment, approvers, rollout_status_id, workspace_id, apiclient=None):
+    def submit_change_request(self, rules, excluded_keys, excluded_segments, operation_type, title, comment, approvers, workspace_id, apiclient=None):
         '''
         submit a change request for rule-based segment definition
 
         :param rules: dictionary of rules to update
+        :param excluded_keys: list of excluded keys
+        :param excluded_segments: list of excluded segments
         :param operation_type: operation type
         :param title: title of the change request
         :param comment: comment for the change request
         :param approvers: list of approvers
-        :param rollout_status_id: rollout status id
         :param workspace_id: id of the workspace
         :param apiclient: If this instance wasn't returned by the client,
             the IdentifyClient instance should be passed in order to perform the
@@ -110,13 +129,14 @@ def submit_change_request(self, rules, operation_type, title, comment, approvers
             'ruleBasedSegment': {
                 'name':self._name,
                 'rules': rules,
+                'excludedKeys': excluded_keys,
+                'excludedSegments': excluded_segments
             },
             'operationType': operation_type,
             'title': title,
             'comment': comment,
             'approvers': approvers,
         }
-        if rollout_status_id is not None:
-            data['rolloutStatus'] = {'id': rollout_status_id}
+
         imc = require_client('ChangeRequest', self._client, apiclient)
         return imc.submit_change_request(self._environment['id'], workspace_id, data)