zscaler-sdk-python 1.1.0__tar.gz → 1.2.1__tar.gz

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zscaler-sdk-python
-Version: 1.1.0
+Version: 1.2.1
 Summary: Official Python SDK for the Zscaler Products
 Home-page: https://github.com/zscaler/zscaler-sdk-python
 License: MIT
@@ -620,6 +620,29 @@ You should now see logs in your console. Notice that API Credentials i.e `client
 
 What it being logged? `requests`, `responses`, `http errors`, `caching responses`.
 
+### Using Your Own Logger (Optional)
+If your script defines its own logging configuration (e.g., for file or custom formatting), the SDK will not interfere with it. You can continue using your own logger like this:
+
+```py
+import logging
+
+my_logger = logging.getLogger("my_app_logger")
+my_logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+my_logger.addHandler(handler)
+
+my_logger.info("This is your app-level log, independent from the SDK.")
+```
+
+To control SDK logging separately, use:
+
+```py
+logging.getLogger("zscaler-sdk-python").setLevel(logging.WARNING)  # or .ERROR to silence SDK logs
+```
+
+The SDK will never globally disable logging or interfere with your existing logging configuration.
+
 ## Configuration reference
 
 This library looks for configuration in the following sources:

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/README.md

@@ -581,6 +581,29 @@ You should now see logs in your console. Notice that API Credentials i.e `client
 
 What it being logged? `requests`, `responses`, `http errors`, `caching responses`.
 
+### Using Your Own Logger (Optional)
+If your script defines its own logging configuration (e.g., for file or custom formatting), the SDK will not interfere with it. You can continue using your own logger like this:
+
+```py
+import logging
+
+my_logger = logging.getLogger("my_app_logger")
+my_logger.setLevel(logging.INFO)
+handler = logging.StreamHandler()
+handler.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
+my_logger.addHandler(handler)
+
+my_logger.info("This is your app-level log, independent from the SDK.")
+```
+
+To control SDK logging separately, use:
+
+```py
+logging.getLogger("zscaler-sdk-python").setLevel(logging.WARNING)  # or .ERROR to silence SDK logs
+```
+
+The SDK will never globally disable logging or interfere with your existing logging configuration.
+
 ## Configuration reference
 
 This library looks for configuration in the following sources:

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/pyproject.toml

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

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/zscaler/__init__.py

@@ -29,7 +29,7 @@ __license__ = "MIT"
 __contributors__ = [
     "William Guilherme",
 ]
-__version__ = "1.1.0"
+__version__ = "1.2.1"
 
 
 from zscaler.oneapi_client import Client as ZscalerClient  # noqa

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/zscaler/constants.py

@@ -15,7 +15,7 @@ ZPA_BASE_URLS = {
 DEV_AUTH_URL = "https://authn1.dev.zpath.net/authn/v1/oauth/token"
 
 
-RETRYABLE_STATUS_CODES = {409, 412, 429, 500, 502, 503, 504}
+RETRYABLE_STATUS_CODES = {408, 409, 412, 429, 500, 502, 503, 504}
 MAX_RETRIES = 5
 BACKOFF_FACTOR = 1
 BACKOFF_BASE_DURATION = 2

zscaler_sdk_python-1.2.1/zscaler/errors/zscaler_api_error.py

@@ -0,0 +1,55 @@
+from zscaler.errors.error import Error
+import json
+
+
+class ZscalerAPIError(Error):
+    def __init__(self, url, response_details, response_body, service_type=""):
+        self.status_code = response_details.status_code
+        self.url = url
+        self.headers = response_details.headers
+        self.stack = ""
+        self.service_type = service_type.lower()
+
+        # Ensure response_body is a dict
+        if not isinstance(response_body, dict):
+            response_body = {"message": str(response_body)}
+
+        # Initialize fields
+        self.error_code = None
+        self.error_message = None
+        self.params = None
+        self.path = None
+
+        # Populate based on service type
+        if self.service_type == "zpa":
+            self.error_code = response_body.get("id")
+            self.error_message = response_body.get("reason")
+            self.params = response_body.get("params")
+        else:  # default to ZIA/others
+            self.error_code = response_body.get("code") or response_body.get("id")
+            self.error_message = response_body.get("message") or response_body.get("reason")
+
+        self.params = self.params or []
+        self.path = response_body.get("path")
+
+        # Construct message string
+        message_parts = [f"HTTP {self.status_code}"]
+        if self.error_code:
+            message_parts.append(self.error_code)
+        if self.error_message:
+            message_parts.append(self.error_message)
+        if self.params:
+            message_parts.append(f"Parameters: {', '.join(self.params)}")
+
+        self.message = " ".join(message_parts)
+
+    def __str__(self):
+        error_payload = {"status": self.status_code, "code": self.error_code, "message": self.error_message, "url": self.url}
+        if self.params:
+            error_payload["params"] = self.params
+        if self.path:
+            error_payload["path"] = self.path
+        return json.dumps(error_payload, indent=2)
+
+    def __repr__(self):
+        return self.__str__()

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/zscaler/exceptions/exceptions.py

@@ -21,10 +21,12 @@ class HTTPException(ZscalerBaseException):
 
 
 class ZscalerAPIException(ZscalerBaseException):
-    pass
+    def __init__(self, error):
+        # error is a ZscalerAPIError
+        super().__init__(error.url, error, error.message)
 
 
-# Zscaler Private Access specific exceptions (Potential Future Use)
+# Other exceptions (unchanged)
 class ZpaBaseException(Exception):
     pass
 
@@ -34,26 +36,18 @@ class ZpaAPIException(ZpaBaseException):
 
 
 class RateLimitExceededError(Exception):
-    """Raised when the API rate limit is exceeded."""
-
     pass
 
 
 class RetryLimitExceededError(Exception):
-    """Raised when the maximum number of retries is exceeded."""
-
     pass
 
 
 class CacheError(Exception):
-    """Raised for errors related to caching operations."""
-
     pass
 
 
 class BadRequestError(Exception):
-    """Raised when the API responds with a 400 status code."""
-
     pass
 
 
@@ -70,32 +64,22 @@ class NotFoundError(Exception):
 
 
 class APIClientError(Exception):
-    """General exception related to the API client operations."""
-
     pass
 
 
 class InvalidCloudEnvironmentError(Exception):
-    """Raised when an unrecognized cloud environment is specified."""
-
     def __init__(self, cloud: str):
         self.cloud = cloud
         super().__init__(f"Unrecognized cloud environment: {self.cloud}")
 
 
 class TokenExpirationError(Exception):
-    """Raised when the authentication token has expired."""
-
     pass
 
 
 class TokenRefreshError(Exception):
-    """Raised when there's an issue refreshing the authentication token."""
-
     pass
 
 
 class HeaderUpdateError(Exception):
-    """Raised if there's a problem updating the session headers."""
-
     pass

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/zscaler/logger.py

@@ -121,4 +121,4 @@ def dump_response(
     if response_body and response_body != "" and response_body != "null":
         log_lines.append(f"\n{response_body}")
     log_lines.append("-" * 68)
-    logger.info("\n".join(log_lines))
+    logger.info("\n".join(log_lines))

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/zscaler/oneapi_http_client.py

@@ -286,7 +286,7 @@ class HTTPClient:
                 )
 
             else:
-                # Use Standard Session
+                # Standard session
                 if self._session:
                     logger.debug("Request with re-usable session.")
                     response = self._session.request(**params)
@@ -294,11 +294,9 @@ class HTTPClient:
                     logger.debug("Request without re-usable session.")
                     response = requests.request(**params)
 
-            if response is None or not hasattr(response, "status_code"):
-                # If we truly got no response (should be rare unless network error)
-                error_msg = "Request execution failed. Response is None."
-                logger.error(error_msg)
-                return (None, ValueError(error_msg))
+            if response is None:
+                logger.error("Request execution failed. Response is None.")
+                return (None, ValueError("No response received."))
 
             dump_request(
                 logger,
@@ -324,7 +322,7 @@ class HTTPClient:
                 request["uuid"],
                 start_time,
             )
-            # Return (response, None) regardless of status code (including 429)
+            # Return response and None even for 4xx/5xx – let check_response_for_error() decide
             return (response, None)
 
         except (requests.RequestException, requests.Timeout) as error:
@@ -334,7 +332,7 @@ class HTTPClient:
 
         except Exception as error:
             # Unexpected errors
-            logger.error(f"Unexpected error during request execution: {error}")
+            # logger.error(f"Unexpected error during request execution: {error}")
             return (None, error)
 
     @staticmethod
@@ -345,47 +343,43 @@ class HTTPClient:
         Args:
             url (str): URL of the response
             response_details (requests.Response): Response object with details
-            response_body (str): Response body in JSON format
+            response_body (str): Response body in JSON or plain string
 
         Returns:
-            Tuple(dict repr of response (if no error), any error found)
+            Tuple(dict or None, error or None)
         """
-        # Check if response is JSON and parse it
-        if "application/json" in response_details.headers.get("Content-Type", ""):
-            try:
-                formatted_response = json.loads(response_body)
-                # logger.debug("Successfully parsed JSON response")
-            except json.JSONDecodeError as e:
-                logger.error(f"Failed to parse JSON response: {e}")
-                return None, e
-        else:
-            formatted_response = response_body
-
-        if 200 <= response_details.status_code < 300:
-            return formatted_response, None
+        content_type = response_details.headers.get("Content-Type", "")
+        is_json = "application/json" in content_type
 
-        logger.error(f"Error response from {url}: {response_details.status_code} - {formatted_response}")
+        # Attempt to parse JSON safely
+        try:
+            formatted_response = json.loads(response_body) if is_json else response_body
+        except json.JSONDecodeError as e:
+            logger.error(f"Failed to parse JSON response: {e}")
+            if HTTPClient.raise_exception:
+                raise HTTPException(f"Invalid JSON response from {url}: {response_body}")
+            return None, HTTPError(url, response_details, response_body)
 
         status_code = response_details.status_code
 
-        # check if call was succesful
-        if 200 <= status_code <= 299:
-            return (formatted_response, None)
-        else:
-            # create errors
-            try:
-                error = ZscalerAPIError(url, response_details, formatted_response)
-                if HTTPClient.raise_exception:
-                    raise ZscalerAPIException(formatted_response)
-            except ZscalerAPIException:
-                raise
-            except Exception:
-                error = HTTPError(url, response_details, formatted_response)
-                if HTTPClient.raise_exception:
-                    logger.exception(formatted_response)
-                    raise HTTPException(formatted_response)
-            logger.error(error)
-            return (None, error)
+        if 200 <= status_code < 300:
+            return formatted_response, None
+
+        # Defensive error handling block (minimal, correct)
+        try:
+            error = ZscalerAPIError(url, response_details, formatted_response)
+            # logger.debug(f"Raw API Error JSON: {json.dumps(formatted_response, indent=2)}")
+            if HTTPClient.raise_exception:
+                raise ZscalerAPIException(error)
+            return None, error
+
+        except Exception as e:
+            # Catch-all in case ZscalerAPIError constructor fails
+            logger.exception("Failed to construct ZscalerAPIError.")
+            generic_error = HTTPError(url, response_details, formatted_response)
+            if HTTPClient.raise_exception:
+                raise HTTPException(str(generic_error)) from e
+            return None, generic_error
 
     @staticmethod
     def format_binary_data(data):

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/zscaler/oneapi_object.py

@@ -13,27 +13,13 @@ class ZscalerObject:
     def __repr__(self):
         return str(vars(self))
 
-    # def as_dict(self):
-    #     """
-    #     Returns dictionary object of ZscalerObject with keys in snake_case for user-facing output.
-    #     """
-    #     result = {}
-    #     for key, val in self.request_format().items():
-    #         if val is None:
-    #             continue
-    #         if isinstance(val, list):
-    #             formatted_list = []
-    #             for item in val:
-    #                 if isinstance(item, ZscalerObject):
-    #                     formatted_list.append(item.as_dict())  # Recursive call for nested objects
-    #                 else:
-    #                     formatted_list.append(item)
-    #             result[to_snake_case(key)] = formatted_list  # Convert key to snake_case
-    #         elif not isinstance(val, ZscalerObject):
-    #             result[to_snake_case(key)] = val  # Convert key to snake_case for simple types
-    #         else:
-    #             result[to_snake_case(key)] = val.as_dict()  # Convert nested objects
-    #     return result
+    def __getitem__(self, key):
+        if hasattr(self, key):
+            return getattr(self, key)
+        raise KeyError(f"{key} not found in {self.__class__.__name__}")
+
+    def __contains__(self, key):
+        return hasattr(self, key)
 
     def as_dict(self):
         result = {}

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/zscaler/oneapi_response.py

@@ -26,8 +26,6 @@ class ZscalerAPIResponse:
         res_details=None,
         response_body="",
         data_type=None,
-        # max_items=None,
-        # max_pages=None,
         all_entries=False,
         sort_order=None,
         sort_by=None,
@@ -181,6 +179,46 @@ class ZscalerAPIResponse:
         self._items_fetched += len(self._list)
         self._pages_fetched += 1
 
+    # def _build_json_response(self, response_body):
+    #     """
+    #     Converts JSON response text into Python dictionary.
+    #     Ensures consistent model conversion for all pages.
+    #     """
+    #     self._body = json.loads(response_body)
+
+    #     # Extract the list based on service type
+    #     if isinstance(self._body, list):
+    #         self._list = self._body
+    #     elif self._service_type == "ZDX":
+    #         self._list = self._body.get("items", [])
+    #         self._next_offset = self._body.get("next_offset")
+    #     else:
+    #         self._list = self._body.get("list", [])
+    #         if self._service_type == "ZPA":
+    #             self._total_pages = int(self._body.get("totalPages", 1))
+    #             self._total_count = int(self._body.get("totalCount", 0))
+
+    #     # Clean and convert items
+    #     cleaned_list = []
+    #     for item in self._list:
+    #         if not isinstance(item, dict):
+    #             logger.warning("Non-dict item found in response list, skipping: %s", item)
+    #             continue
+                
+    #         # Convert to model if type is specified
+    #         if self._type:
+    #             try:
+    #                 cleaned_list.append(self._type(**item))
+    #             except Exception as e:
+    #                 logger.error("Failed to convert item to model: %s", e)
+    #                 cleaned_list.append(item)
+    #         else:
+    #             cleaned_list.append(item)
+
+    #     self._list = cleaned_list
+    #     self._items_fetched += len(self._list)
+    #     self._pages_fetched += 1
+    
     def get_results(self):
         """
         Returns the current page of results.
@@ -198,36 +236,104 @@ class ZscalerAPIResponse:
         """
         return self._has_next()
 
-    def next(self):
-        """
-        Fetch the next page of results if available.
-
-        Returns:
-            tuple: (list of items, error)
+    # def next(self):
+    #     """
+    #     Fetch the next page of results if available.
+
+    #     Returns:
+    #         tuple: (list of items, error)
+
+    #     If there's an error fetching the next page, returns (None, error).
+    #     If no more pages exist, returns (None, None).
+    #     """
+    #     if not self.has_next():
+    #         logger.debug("No further pages to retrieve.")
+    #         return (None, None)
+
+    #     next_page_results = self._fetch_next_page()
+    #     if next_page_results is None:
+    #         # An error occurred, already logged
+    #         return (None, ValueError("Error fetching next page."))
+    #     if not next_page_results:
+    #         # Empty result means no more data
+    #         return (None, None)
+    #     return (next_page_results, None)
+
+### Latest working function
+    # def next(self):
+    #     if not self.has_next():
+    #         raise StopIteration("No more pages available.")
+
+    #     results, error = self._fetch_next_page()
+    #     if error:
+    #         return None, error
+    #     if not results:
+    #         return None, None
+
+    #     if self._type:
+    #         try:
+    #             results = [self._type(item) for item in results if isinstance(item, dict)]
+    #         except Exception as wrap_error:
+    #             logger.warning(f"Failed to wrap pagination results with {self._type}: {wrap_error}")
+
+    #     return results, None
 
-        If there's an error fetching the next page, returns (None, error).
-        If no more pages exist, returns (None, None).
-        """
+    def next(self):
         if not self.has_next():
-            logger.debug("No further pages to retrieve.")
-            return (None, None)
-
-        next_page_results = self._fetch_next_page()
-        if next_page_results is None:
-            # An error occurred, already logged
-            return (None, ValueError("Error fetching next page."))
-        if not next_page_results:
-            # Empty result means no more data
-            return (None, None)
-        return (next_page_results, None)
+            raise StopIteration("No more pages available.")
+
+        results, error = self._fetch_next_page()
+        if error:
+            return None, self, error
+        if not results:
+            return None, self, None
+
+        if self._type:
+            try:
+                results = [self._type(item) for item in results if isinstance(item, dict)]
+            except Exception as wrap_error:
+                logger.warning(f"Failed to wrap pagination results with {self._type}: {wrap_error}")
+
+        return results, self, None
+
+
+    # def _fetch_next_page(self):
+    #     """
+    #     Internal method that fetches and returns the next page of results.
+    #     """
+    #     if not self._has_next():
+    #         logger.debug("No more pages to fetch")
+    #         return []
+
+    #     if self._service_type == "ZDX":
+    #         self._params["offset"] = self._next_offset
+    #     else:
+    #         self._page += 1
+    #         self._params["page"] = self._page
+
+    #     logger.debug(f"Requesting next page with params: {self._params}")
+
+    #     req = {
+    #         "method": "GET",
+    #         "url": self._url,
+    #         "headers": self._headers,
+    #         "params": self._params,
+    #         "uuid": uuid.uuid4(),
+    #     }
+    #     _, _, response_body, error = self._request_executor.fire_request(req)
+
+    #     if error:
+    #         logger.error(f"Error fetching the next page: {error}")
+    #         return None
+
+    #     # Rebuild the response body for the next page
+    #     self._build_json_response(response_body)
+    #     return self._list
 
     def _fetch_next_page(self):
-        """
-        Internal method that fetches and returns the next page of results.
-        """
         if not self._has_next():
             logger.debug("No more pages to fetch")
-            return []
+            return [], None
 
         if self._service_type == "ZDX":
             self._params["offset"] = self._next_offset
@@ -248,11 +354,10 @@ class ZscalerAPIResponse:
 
         if error:
             logger.error(f"Error fetching the next page: {error}")
-            return None
+            return None, error
 
-        # Rebuild the response body for the next page
         self._build_json_response(response_body)
-        return self._list
+        return self._list, None
 
     def _has_next(self):
         # Check max_items or max_pages constraints

{zscaler_sdk_python-1.1.0 → zscaler_sdk_python-1.2.1}/zscaler/request_executor.py

@@ -20,7 +20,7 @@ logger = logging.getLogger(__name__)
 
 class RequestExecutor:
     """
-    This class handles all of the requests sent by the Zscaler SDK Client (ZIA, ZPA, ZCC, ZDX, ZWA etc.).
+    This class handles all of the requests sent by the Zscaler SDK Client (ZIA, ZPA, ZCC, ZDX, ZWA, ZTW).
     """
 
     BASE_URL = "https://api.zsapi.net"  # Default base URL for API calls
@@ -323,16 +323,18 @@ class RequestExecutor:
         """
         try:
             request, response, response_body, error = self.fire_request(request)
+            logger.debug(
+                f"[DEBUG] Got response: {response} (status: {getattr(response, 'status_code', 'N/A')}) | error: {error}"
+            )
         except Exception as ex:
             logger.error(f"Exception during HTTP request: {ex}")
             return None, ex
 
-        if not response:
-            logger.error("Response is None after executing request.")
-            return None, ValueError("Response is None")
+        if response is None and error is None:
+            return None, None  # silently return None without manufacturing errors
 
         if error:
-            logger.error(f"Error during request execution: {error}")
+            # logger.error(f"Error during request execution: {error}")
             return None, error
 
         if response.status_code == 204:
@@ -350,7 +352,7 @@ class RequestExecutor:
             return None, ex
 
         if error:
-            logger.error(f"Error in HTTP response: {error}")
+            # logger.error(f"Error in HTTP response: {error}")
             return None, error
 
         logger.debug(f"Successful response from {request['url']}")
@@ -466,8 +468,8 @@ class RequestExecutor:
         response, error = self._http_client.send_request(request)
 
         if error:
-            logger.error(f"Error sending request: {error}")
-            return None, None, None, error
+            # logger.error(f"Error sending request: {error}")
+            return request, response, response.text if response else None, error
 
         headers = response.headers
 
@@ -486,10 +488,14 @@ class RequestExecutor:
         """
         Checks if HTTP status is retryable.
 
-        Retryable statuses: 429, 503, 504
+        Retryable statuses: 408, 409, 412, 429, 500, 502, 503, 504
         """
         return status is not None and status in (
+            HTTPStatus.REQUEST_TIMEOUT,
+            HTTPStatus.CONFLICT,
+            HTTPStatus.PRECONDITION_FAILED,
             HTTPStatus.TOO_MANY_REQUESTS,
+            HTTPStatus.INTERNAL_SERVER_ERROR,
             HTTPStatus.SERVICE_UNAVAILABLE,
             HTTPStatus.GATEWAY_TIMEOUT,
         )