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

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

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zscaler-sdk-python"
-version = "1.2.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.2.0 → zscaler_sdk_python-1.2.1}/zscaler/__init__.py

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

zscaler_sdk_python-1.2.1/zscaler/logger.py

@@ -0,0 +1,124 @@
+import logging
+import json as jsonp
+import os
+import time
+from urllib.parse import urlencode
+from http.client import HTTPConnection
+
+LOG_FORMAT = "%(asctime)s - %(name)s - %(module)s - %(levelname)s - %(message)s"
+
+
+def setup_logging(logger_name="zscaler-sdk-python", enabled=None, verbose=None):
+    """
+    Set up logging with specified level and logger name.
+    Log level is controlled via ZSCALER_SDK_VERBOSE environment variable.
+    Logging can be enabled/disabled via ZSCALER_SDK_LOG environment variable.
+
+    Parameters:
+    - logger_name (str, optional): Logger name. Defaults to "zscaler-sdk-python".
+    - enabled (bool, optional): Enable logging. Defaults to None, which uses the environment variable.
+    - verbose (bool, optional): Set verbose logging. Defaults to None, which uses the environment variable.
+    """
+    if enabled is None:
+        enabled = os.getenv("ZSCALER_SDK_LOG", "false").lower() == "true"
+
+    if not enabled:
+        # If logging is not enabled, set up a null handler
+        logging.disable(logging.INFO)
+        return
+
+    if verbose is None:
+        verbose = os.getenv("ZSCALER_SDK_VERBOSE", "false").lower() == "true"
+
+    log_level = logging.DEBUG if verbose else logging.INFO
+    HTTPConnection.debuglevel = 0
+    # Create a logger with the specified name
+    logger = logging.getLogger(logger_name)
+    default_logger = logging.getLogger()
+
+    # If the logger already has handlers, remove them to avoid duplicate logging
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
+
+    for handler in default_logger.handlers[:]:
+        default_logger.removeHandler(handler)
+
+    # Set log level
+    logger.setLevel(log_level)
+    default_logger.setLevel(log_level)
+    logging.basicConfig(level=log_level)
+    # Create a stream handler with the specified level and formatter
+    stream_handler = logging.StreamHandler()
+    stream_handler.setLevel(log_level)
+    log_formatter = logging.Formatter(LOG_FORMAT)
+    stream_handler.setFormatter(log_formatter)
+
+    # Add the handler to the logger
+    logger.addHandler(stream_handler)
+
+    # Option: Add FileHandler if you want logs to be written to a file.
+    if os.getenv("LOG_TO_FILE", "false").lower() == "true":
+        file_handler = logging.FileHandler(os.getenv("LOG_FILE_PATH", "sdk.log"))
+        file_handler.setLevel(log_level)
+        file_handler.setFormatter(log_formatter)
+        logger.addHandler(file_handler)
+
+
+def dump_request(logger, url: str, method: str, json, params, headers, request_uuid: str, body=True):
+    request_headers_filtered = {key: value for key, value in headers.items() if key != "Authorization"}
+    # Log the request details before sending the request
+    log_lines = []
+    request_body = ""
+    if body:
+        request_body = jsonp.dumps(json)
+    log_lines.append(f"\n---[ ZSCALER SDK REQUEST | ID:{request_uuid} ]-------------------------------")
+    full_url = url
+    if params:
+        full_url += "?" + urlencode(params)
+    log_lines.append(f"{method} {full_url}")
+    for key, value in request_headers_filtered.items():
+        log_lines.append(f"{key}: {value}")
+    if body and request_body != "" and request_body != "null":
+        log_lines.append(f"\n{request_body}")
+    log_lines.append("--------------------------------------------------------------------")
+    logger.info("\n".join(log_lines))
+
+
+def dump_response(
+    logger,
+    url: str,
+    method: str,
+    resp,
+    params,
+    request_uuid: str,
+    start_time,
+    from_cache: bool = None,
+):
+    # Calculate the duration in seconds
+    end_time = time.time()
+    duration_seconds = end_time - start_time
+    # Convert the duration to milliseconds
+    duration_ms = duration_seconds * 1000
+    # Convert the headers to a regular dictionary
+    response_headers_dict = dict(resp.headers)
+    full_url = url
+    if params:
+        full_url += "?" + urlencode(params)
+    log_lines = []
+
+    if from_cache:
+        log_lines.append(
+            f"\n---[ ZSCALER SDK RESPONSE | ID:{request_uuid} | " f"FROM CACHE | DURATION:{duration_ms}ms ]" + "-" * 31
+        )
+    else:
+        log_lines.append(f"\n---[ ZSCALER SDK RESPONSE | ID:{request_uuid} | " f"DURATION:{duration_ms}ms ]" + "-" * 46)
+    log_lines.append(f"{method} {full_url}")
+    for key, value in response_headers_dict.items():
+        log_lines.append(f"{key}: {value}")
+    response_body = ""
+    if resp.text:
+        response_body = resp.text
+    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))

{zscaler_sdk_python-1.2.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.2.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.2.0 → zscaler_sdk_python-1.2.1}/zscaler/zia/bandwidth_classes.py

@@ -65,26 +65,32 @@ class BandwidthClassesAPI(APIClient):
 
         query_params = query_params or {}
 
+        local_search = query_params.pop("search", None)
+
         body = {}
         headers = {}
 
         request, error = self._request_executor.create_request(http_method, api_url, body, headers, params=query_params)
-
         if error:
             return (None, None, error)
 
         response, error = self._request_executor.execute(request)
-
         if error:
             return (None, response, error)
 
         try:
-            result = []
+            results = []
             for item in response.get_results():
-                result.append(BandwidthClasses(self.form_response_body(item)))
-        except Exception as error:
-            return (None, response, error)
-        return (result, response, None)
+                results.append(BandwidthClasses(self.form_response_body(item)))
+        except Exception as exc:
+            return (None, response, exc)
+
+        if local_search:
+            lower_search = local_search.lower()
+            results = [r for r in results if lower_search in (r.name.lower() if r.name else "")]
+
+        return (results, response, None)
+
 
     def list_classes_lite(self) -> tuple:
         """

{zscaler_sdk_python-1.2.0 → zscaler_sdk_python-1.2.1}/zscaler/zia/legacy.py

@@ -289,19 +289,16 @@ class LegacyZIAClientHelper:
                     continue
 
                 if resp.status_code >= 400:
-                    try:
-                        response_body = resp.json()
-                    except Exception:
-                        response_body = {"message": resp.text}
-
-                    error = ZscalerAPIError(
-                        url=url,
-                        response_details=resp,
-                        response_body=response_body,
-                        service_type="zia",  # Or dynamically inferred
-                    )
-                    logger.error(f"{error}")
-                    raise error
+                    logger.error(f"Request failed: {resp.status_code}, {resp.text}")
+                    raise ValueError(f"Request failed with status {resp.status_code}")
+
+                return resp, {
+                    "method": method,
+                    "url": url,
+                    "params": params or {},
+                    "headers": headers_with_user_agent,
+                    "json": json or {},
+                }
             except requests.RequestException as e:
                 logger.error(f"Request to {url} failed: {e}")
                 if attempts == 4:

{zscaler_sdk_python-1.2.0 → zscaler_sdk_python-1.2.1}/zscaler/zpa/application_segment.py

@@ -88,7 +88,7 @@ class ApplicationSegmentAPI(APIClient):
         if error:
             return (None, None, error)
 
-        response, error = self._request_executor.execute(request)
+        response, error = self._request_executor.execute(request, ApplicationSegment)
         if error:
             return (None, response, error)
 

{zscaler_sdk_python-1.2.0 → zscaler_sdk_python-1.2.1}/zscaler/zpa/legacy.py

@@ -198,9 +198,9 @@ class LegacyZPAClientHelper:
         self._session = session
 
     @property
-    def authdomains(self):
+    def customer_controller(self):
         """
-        The interface object for the :ref:`ZPA Auth Domains interface <zpa-authdomains>`.
+        The interface object for the :ref:`ZPA Auth Domains interface <zpa-customer_controller>`.
 
         """
         from zscaler.zpa.customer_controller import CustomerControllerAPI

zscaler_sdk_python-1.2.0/zscaler/logger.py

@@ -1,181 +0,0 @@
-import logging
-import json as jsonp
-import os
-import time
-from urllib.parse import urlencode
-from http.client import HTTPConnection
-
-LOG_FORMAT = "%(asctime)s - %(name)s - %(module)s - %(levelname)s - %(message)s"
-
-
-# def setup_logging(logger_name="zscaler-sdk-python", enabled=None, verbose=None):
-#     """
-#     Set up logging with specified level and logger name.
-#     Log level is controlled via ZSCALER_SDK_VERBOSE environment variable.
-#     Logging can be enabled/disabled via ZSCALER_SDK_LOG environment variable.
-
-#     Parameters:
-#     - logger_name (str, optional): Logger name. Defaults to "zscaler-sdk-python".
-#     - enabled (bool, optional): Enable logging. Defaults to None, which uses the environment variable.
-#     - verbose (bool, optional): Set verbose logging. Defaults to None, which uses the environment variable.
-#     """
-#     if enabled is None:
-#         enabled = os.getenv("ZSCALER_SDK_LOG", "false").lower() == "true"
-
-#     # if not enabled:
-#     #     # If logging is not enabled, set up a null handler
-#     #     logging.disable(logging.INFO)
-#     #     return
-
-#     if not enabled:
-#         # Do not globally disable logging
-#         # Just keep the SDK logger silent
-#         sdk_logger = logging.getLogger(logger_name)
-#         sdk_logger.addHandler(logging.NullHandler())
-#         return
-
-#     if verbose is None:
-#         verbose = os.getenv("ZSCALER_SDK_VERBOSE", "false").lower() == "true"
-
-#     log_level = logging.DEBUG if verbose else logging.INFO
-#     HTTPConnection.debuglevel = 0
-#     # Create a logger with the specified name
-#     logger = logging.getLogger(logger_name)
-#     default_logger = logging.getLogger()
-
-#     # If the logger already has handlers, remove them to avoid duplicate logging
-#     for handler in logger.handlers[:]:
-#         logger.removeHandler(handler)
-
-#     for handler in default_logger.handlers[:]:
-#         default_logger.removeHandler(handler)
-
-#     # Set log level
-#     logger.setLevel(log_level)
-#     default_logger.setLevel(log_level)
-#     logging.basicConfig(level=log_level)
-#     # Create a stream handler with the specified level and formatter
-#     stream_handler = logging.StreamHandler()
-#     stream_handler.setLevel(log_level)
-#     log_formatter = logging.Formatter(LOG_FORMAT)
-#     stream_handler.setFormatter(log_formatter)
-
-#     # Add the handler to the logger
-#     logger.addHandler(stream_handler)
-
-
-#     # Option: Add FileHandler if you want logs to be written to a file.
-#     if os.getenv("LOG_TO_FILE", "false").lower() == "true":
-#         file_handler = logging.FileHandler(os.getenv("LOG_FILE_PATH", "sdk.log"))
-#         file_handler.setLevel(log_level)
-#         file_handler.setFormatter(log_formatter)
-#         logger.addHandler(file_handler)
-def setup_logging(logger_name="zscaler-sdk-python", enabled=None, verbose=None):
-    """
-    Set up logging for the Zscaler SDK.
-
-    Logging behavior can be controlled via environment variables or config:
-
-    Environment Variables:
-        ZSCALER_SDK_LOG (true/false): Enable or disable SDK logging.
-        ZSCALER_SDK_VERBOSE (true/false): Enable verbose (DEBUG) logging.
-        LOG_TO_FILE (true/false): Enable file-based logging.
-        LOG_FILE_PATH: File path for logs (default: sdk.log)
-
-    Parameters:
-        logger_name (str): Name of the logger. Defaults to "zscaler-sdk-python".
-        enabled (bool): Enable logging. If None, reads from env.
-        verbose (bool): Enable DEBUG-level logging. If None, reads from env.
-    """
-    if enabled is None:
-        enabled = os.getenv("ZSCALER_SDK_LOG", "false").lower() == "true"
-
-    if not enabled:
-        # Do NOT disable global logging.
-        # Just suppress SDK logs quietly with a NullHandler.
-        logging.getLogger(logger_name).addHandler(logging.NullHandler())
-        return
-
-    if verbose is None:
-        verbose = os.getenv("ZSCALER_SDK_VERBOSE", "false").lower() == "true"
-
-    log_level = logging.DEBUG if verbose else logging.INFO
-    HTTPConnection.debuglevel = 0  # Optional: Enable HTTP debug logging
-
-    # SDK logger (isolated)
-    logger = logging.getLogger(logger_name)
-    logger.setLevel(log_level)
-
-    # Clean up any duplicate handlers
-    if not logger.handlers:
-        stream_handler = logging.StreamHandler()
-        stream_handler.setLevel(log_level)
-        stream_handler.setFormatter(logging.Formatter(LOG_FORMAT))
-        logger.addHandler(stream_handler)
-
-        # Optional file logging
-        if os.getenv("LOG_TO_FILE", "false").lower() == "true":
-            file_handler = logging.FileHandler(os.getenv("LOG_FILE_PATH", "sdk.log"))
-            file_handler.setLevel(log_level)
-            file_handler.setFormatter(logging.Formatter(LOG_FORMAT))
-            logger.addHandler(file_handler)
-
-
-def dump_request(logger, url: str, method: str, json, params, headers, request_uuid: str, body=True):
-    request_headers_filtered = {key: value for key, value in headers.items() if key != "Authorization"}
-    # Log the request details before sending the request
-    log_lines = []
-    request_body = ""
-    if body:
-        request_body = jsonp.dumps(json)
-    log_lines.append(f"\n---[ ZSCALER SDK REQUEST | ID:{request_uuid} ]-------------------------------")
-    full_url = url
-    if params:
-        full_url += "?" + urlencode(params)
-    log_lines.append(f"{method} {full_url}")
-    for key, value in request_headers_filtered.items():
-        log_lines.append(f"{key}: {value}")
-    if body and request_body != "" and request_body != "null":
-        log_lines.append(f"\n{request_body}")
-    log_lines.append("--------------------------------------------------------------------")
-    logger.info("\n".join(log_lines))
-
-
-def dump_response(
-    logger,
-    url: str,
-    method: str,
-    resp,
-    params,
-    request_uuid: str,
-    start_time,
-    from_cache: bool = None,
-):
-    # Calculate the duration in seconds
-    end_time = time.time()
-    duration_seconds = end_time - start_time
-    # Convert the duration to milliseconds
-    duration_ms = duration_seconds * 1000
-    # Convert the headers to a regular dictionary
-    response_headers_dict = dict(resp.headers)
-    full_url = url
-    if params:
-        full_url += "?" + urlencode(params)
-    log_lines = []
-
-    if from_cache:
-        log_lines.append(
-            f"\n---[ ZSCALER SDK RESPONSE | ID:{request_uuid} | " f"FROM CACHE | DURATION:{duration_ms}ms ]" + "-" * 31
-        )
-    else:
-        log_lines.append(f"\n---[ ZSCALER SDK RESPONSE | ID:{request_uuid} | " f"DURATION:{duration_ms}ms ]" + "-" * 46)
-    log_lines.append(f"{method} {full_url}")
-    for key, value in response_headers_dict.items():
-        log_lines.append(f"{key}: {value}")
-    response_body = ""
-    if resp.text:
-        response_body = resp.text
-    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))