zscaler-sdk-python 0.9.6__tar.gz → 0.9.7__tar.gz

{zscaler_sdk_python-0.9.6 → zscaler_sdk_python-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zscaler-sdk-python
-Version: 0.9.6
+Version: 0.9.7
 Summary: Official Python SDK for the Zscaler Products (Beta)
 Home-page: https://github.com/zscaler/zscaler-sdk-python
 License: MIT

{zscaler_sdk_python-0.9.6 → zscaler_sdk_python-0.9.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zscaler-sdk-python"
-version = "0.9.6"
+version = "0.9.7"
 description = "Official Python SDK for the Zscaler Products (Beta)"
 authors = ["Zscaler, Inc. <devrel@zscaler.com>"]
 license = "MIT"

{zscaler_sdk_python-0.9.6 → zscaler_sdk_python-0.9.7}/zscaler/__init__.py

@@ -29,7 +29,7 @@ __license__ = "MIT"
 __contributors__ = [
     "William Guilherme",
 ]
-__version__ = "0.9.6"
+__version__ = "0.9.7"
 
 from zscaler.zdx import ZDXClientHelper  # noqa
 from zscaler.zia import ZIAClientHelper  # noqa

{zscaler_sdk_python-0.9.6 → zscaler_sdk_python-0.9.7}/zscaler/zia/__init__.py

@@ -406,6 +406,9 @@ class ZIAClientHelper(ZIAClient):
         page=None,
         pagesize=None,
         search=None,
+        max_page_size=1000,  # Default to 1000, can be adjusted based on endpoint constraints
+        max_items=None,  # Maximum number of items to retrieve across pages
+        max_pages=None,  # Maximum number of pages to retrieve
     ):
         """
         Fetches paginated data from the API based on specified parameters and handles pagination.
@@ -416,6 +419,8 @@ class ZIAClientHelper(ZIAClient):
             page (int): Specific page number to fetch. Defaults to 1 if not provided.
             pagesize (int): Number of items per page, default is 100, with a maximum of 1000.
             search (str): Search query to filter the results.
+            max_items (int): Maximum number of items to retrieve.
+            max_pages (int): Maximum number of pages to fetch.
 
         Returns:
             tuple: A tuple containing:
@@ -428,15 +433,18 @@ class ZIAClientHelper(ZIAClient):
             "UNEXPECTED_STATUS": "Unexpected status code {status_code} received for page {page}.",
             "EMPTY_RESULTS": "No results found for page {page}.",
         }
-    
-        params = {}
-        params["page"] = page if page is not None else 1  # Default to page 1
-        params["pagesize"] = min(pagesize if pagesize is not None else 100, 1000)  # Default pagesize is 100, max 1000
+
+        # Initialize pagination parameters
+        params = {
+            "page": page if page is not None else 1,  # Start at page 1 if not specified
+            "pagesize": min(pagesize if pagesize is not None else 100, max_page_size)  # Apply max_page_size limit
+        }
 
         if search:
             params["search"] = search
 
         ret_data = []
+        total_collected = 0  # Track total items collected
 
         try:
             while True:
@@ -464,18 +472,26 @@ class ZIAClientHelper(ZIAClient):
                     return BoxList([]), error_msg
 
                 data = convert_keys_to_snake(response_data)
-                
+
                 # If searching for a specific item, stop if we find a match
                 if search:
                     for item in data:
                         if item.get("name") == search:
                             ret_data.append(item)
                             return BoxList(ret_data), None
-                
-                # If no search, collect all data from the current page
+
+                # Limit data collection based on max_items
+                if max_items is not None:
+                    data = data[:max_items - total_collected]  # Limit items on the current page
                 ret_data.extend(data)
+                total_collected += len(data)
+
+                # Check if we've reached max_items or max_pages limits
+                if (max_items is not None and total_collected >= max_items) or \
+                   (max_pages is not None and params["page"] >= max_pages):
+                    break
 
-                # Stop if we've processed all available pages
+                # Stop if we've processed all available pages (i.e., less than requested page size)
                 if len(data) < params["pagesize"]:
                     break
 

{zscaler_sdk_python-0.9.6 → zscaler_sdk_python-0.9.7}/zscaler/zia/security.py

@@ -163,11 +163,23 @@ class SecurityPolicyAPI:
 
         payload = {"blacklistUrls": url_list}
 
-        resp = self.rest.post("security/advanced/blacklistUrls?action=ADD_TO_LIST", json=payload).status_code
-
-        # Return the object if it was updated successfully
-        if resp == 204:
-            return self.get_blacklist()
+        try:
+            # Send the POST request to add URLs to the blacklist
+            response = self.rest.post("security/advanced/blacklistUrls?action=ADD_TO_LIST", json=payload)
+            
+            # Check if the response includes an empty 'blacklistUrls', signaling no update
+            if "blacklistUrls" in response and not response["blacklistUrls"]:
+                raise Exception("Failed to add URLs to blacklist: The API response returned an empty 'blacklistUrls' list.")
+
+            # Verify the URLs were added by checking the current blacklist
+            updated_blacklist = self.get_blacklist()
+            if all(url in updated_blacklist for url in url_list):
+                return updated_blacklist
+            else:
+                raise Exception("Failed to add URLs to blacklist: URLs were not present in the updated blacklist.")
+                
+        except Exception as exc:
+            raise Exception(f"Failed to add URLs to blacklist: {exc}")
 
     def replace_blacklist(self, url_list: list) -> BoxList:
         """

{zscaler_sdk_python-0.9.6 → zscaler_sdk_python-0.9.7}/zscaler/zia/users.py

@@ -71,7 +71,7 @@ class UserManagementAPI:
         """
         list, _ = self.rest.get_paginated_data(path="/departments", **kwargs)
         return list
-
+    
     def get_department(self, department_id: str) -> Box:
         """
         Returns the department details for a given department.

{zscaler_sdk_python-0.9.6 → zscaler_sdk_python-0.9.7}/zscaler/zpa/__init__.py

@@ -369,27 +369,27 @@ class ZPAClientHelper(ZPAClient):
         return self.send("DELETE", path, json, params, api_version=api_version)
 
     def get_paginated_data(
-        self,
-        path=None,
-        params=None,
-        expected_status_code=200,
-        api_version: str = None,
-        search=None,
-        search_field="name",
-        max_pages=None,
-        max_items=None,
-        all_entries=False,  # Return all SCIM groups including the deleted ones if set to true
-        sort_order=None,
-        sort_by=None,
-        sort_dir=None,
-        start_time=None,
-        end_time=None,
-        idp_group_id=None,
-        scim_user_id=None,
-        scim_username=None,
-        page=None,
-        pagesize=None,
-        microtenant_id=None,
+    self,
+    path=None,
+    params=None,
+    expected_status_code=200,
+    api_version: str = None,
+    search=None,
+    search_field="name",
+    max_pages=None,
+    max_items=None,
+    all_entries=False,
+    sort_order=None,
+    sort_by=None,
+    sort_dir=None,
+    start_time=None,
+    end_time=None,
+    idp_group_id=None,
+    scim_user_id=None,
+    scim_username=None,
+    page=None,
+    pagesize=None,
+    microtenant_id=None,
     ):
         """
         Fetches paginated data from the ZPA API based on specified parameters and handles various types of API pagination.
@@ -432,15 +432,10 @@ class ZPAClientHelper(ZPAClient):
         if params is None:
             params = {}
 
-        if (page is not None or pagesize is not None) and (max_pages is not None or max_items is not None):
-            raise ValueError(
-                "Do not mix 'page' or 'pagesize' with 'max_pages' or 'max_items'. Choose either set of parameters."
-            )
-
-        params["page"] = page if page is not None else 1  # Default to page 1 if not specified
-        params["pagesize"] = min(pagesize if pagesize is not None else 20, 500)  # Apply maximum constraint and handle default
+        # Set initial pagination params
+        params["page"] = page or 1
+        params["pagesize"] = min(pagesize, 500) if pagesize else 500
 
-        # Check for microtenantId in function arguments first, then environment variable
         if microtenant_id:
             params["microtenantId"] = microtenant_id
         elif self.microtenant_id and "microtenantId" not in params:
@@ -472,7 +467,8 @@ class ZPAClientHelper(ZPAClient):
 
         try:
             while True:
-                if max_pages is not None and (page is not None and page > max_pages):
+                # Stop if max_pages reached
+                if max_pages is not None and params["page"] > max_pages:
                     break
 
                 should_wait, delay = self.rate_limiter.wait("GET")
@@ -490,23 +486,27 @@ class ZPAClientHelper(ZPAClient):
 
                 response_data = response.json()
                 data = response_data.get("list", [])
-                if not data and (params["page"] == 1):
+                if not data and params["page"] == 1:
                     error_msg = ERROR_MESSAGES["EMPTY_RESULTS"]
                     logger.warn(error_msg)
                     return BoxList([]), error_msg
 
+                # Convert and extend the collected data
                 data = convert_keys_to_snake(data)
                 ret_data.extend(data[: max_items - total_collected] if max_items is not None else data)
                 total_collected += len(data)
 
+                # Check if we’ve collected the max_items
                 if max_items is not None and total_collected >= max_items:
                     break
 
-                next_page = response_data.get("nextPage")
-                if not next_page or (max_pages is not None and params["page"] >= max_pages):
+                # Determine if there is a next page based on totalPages, converting totalPages to an integer if present
+                total_pages = int(response_data.get("totalPages", 0))  # Default to 0 if not provided
+                if not total_pages or params["page"] >= total_pages:
                     break
 
-                params["page"] = next_page if params["page"] is None else params["page"] + 1
+                # Move to the next page
+                params["page"] += 1
 
         finally:
             time.sleep(2)  # Ensure a delay between requests regardless of outcome

{zscaler_sdk_python-0.9.6 → zscaler_sdk_python-0.9.7}/zscaler/zpa/policies.py

@@ -56,7 +56,7 @@ class PolicySetsAPI:
             conditions (list): List of condition dicts or tuples.
 
         Returns:
-            :obj:`dict`: The conditions template.
+            :obj:`list`: The conditions template.
 
         """
         template = []
@@ -78,75 +78,47 @@ class PolicySetsAPI:
             "COUNTRY_CODE": [],
         }
 
-        current_operator = "OR"  # Default operator
-        
+        operators_for_types = {}  # Dictionary to store specific operators for each object type
+
         for condition in conditions:
-            # Check if the first item is an operator, like "AND" or "OR"
+            # Check if the first item in a tuple is an operator, like "AND" or "OR"
             if isinstance(condition, tuple) and isinstance(condition[0], str) and condition[0].upper() in ["AND", "OR"]:
-                current_operator = condition[0].upper()  # Set the current operator
+                operator = condition[0].upper()
                 condition = condition[1]  # The second element is the actual condition
+            else:
+                operator = "OR"  # Default operator if none specified
 
+            # Process each condition and categorize by object type and operator
             if isinstance(condition, tuple) and len(condition) == 3:
-                # Handle each object type according to its pattern
                 object_type = condition[0].upper()
                 lhs = condition[1]
                 rhs = condition[2]
+                operand = {"objectType": object_type, "lhs": lhs, "rhs": rhs}
+
+                # Track the operator for the current object type
+                operators_for_types[object_type] = operator
 
                 if object_type in ["APP", "APP_GROUP"]:
-                    app_and_app_group_operands.append({"objectType": object_type, "lhs": "id", "rhs": rhs})
+                    app_and_app_group_operands.append(operand)
                 elif object_type in object_types_to_operands:
-                    if object_type == "CLIENT_TYPE":
-                        if rhs in {
-                            "zpn_client_type_exporter",
-                            "zpn_client_type_machine_tunnel",
-                            "zpn_client_type_ip_anchoring",
-                            "zpn_client_type_edge_connector",
-                            "zpn_client_type_zapp",
-                            "zpn_client_type_slogger",
-                        }:
-                            object_types_to_operands[object_type].append({"objectType": object_type, "lhs": "id", "rhs": rhs})
-                    elif object_type in [
-                        "PLATFORM",
-                        "POSTURE",
-                        "TRUSTED_NETWORK",
-                        "SAML",
-                        "SCIM",
-                        "SCIM_GROUP",
-                        "COUNTRY_CODE",
-                    ]:
-                        object_types_to_operands[object_type].append({"objectType": object_type, "lhs": lhs, "rhs": rhs})
-                    else:
-                        object_types_to_operands[object_type].append({"objectType": object_type, "lhs": "id", "rhs": rhs})
-                        
+                    object_types_to_operands[object_type].append(operand)
+
             elif isinstance(condition, dict):
-                # This part allows passing operator explicitly through conditions
                 if "operator" in condition:
-                    current_operator = condition["operator"]
-                    continue  # Move to the next condition after setting the operator
+                    operators_for_types["default"] = condition["operator"]
+                    continue  # Skip to the next condition after setting the operator
 
-                # Handle the dictionary logic based on the Go code schema
                 condition_template = {}
-                # Extracting keys from the condition dictionary
                 for key in ["id", "negated", "operator"]:
                     if key in condition:
                         condition_template[key] = condition[key]
 
-                # Handling the operands
                 operands = condition.get("operands", [])
                 condition_template["operands"] = []
 
                 for operand in operands:
                     operand_template = {}
-
-                    # Extracting keys from the operand dictionary
-                    for operand_key in [
-                        "id",
-                        "idp_id",
-                        "name",
-                        "lhs",
-                        "rhs",
-                        "objectType",
-                    ]:
+                    for operand_key in ["id", "idp_id", "name", "lhs", "rhs", "objectType"]:
                         if operand_key in operand:
                             operand_template[operand_key] = operand[operand_key]
 
@@ -154,14 +126,16 @@ class PolicySetsAPI:
 
                 template.append(condition_template)
 
-        # Combine APP and APP_GROUP operands into one block
+        # Combine APP and APP_GROUP operands with their specific operator
         if app_and_app_group_operands:
-            template.append({"operator": current_operator, "operands": app_and_app_group_operands})
+            app_group_operator = operators_for_types.get("APP", "OR")
+            template.append({"operator": app_group_operator, "operands": app_and_app_group_operands})
 
-        # Combine other object types into their own blocks
+        # Combine other object types into their blocks with their respective operator
         for object_type, operands in object_types_to_operands.items():
             if operands:
-                template.append({"operator": current_operator, "operands": operands})
+                operator = operators_for_types.get(object_type, "OR")
+                template.append({"operator": operator, "operands": operands})
 
         return template