zscaler-sdk-python 1.9.13__tar.gz → 1.9.14__tar.gz

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zscaler-sdk-python
-Version: 1.9.13
+Version: 1.9.14
 Summary: Official Python SDK for the Zscaler Products
 Home-page: https://github.com/zscaler/zscaler-sdk-python
 License: MIT
@@ -24,7 +24,6 @@ Requires-Dist: PyJWT (>=2.10.1)
 Requires-Dist: aenum (>=3.1.11)
 Requires-Dist: arrow (>=1.3.0)
 Requires-Dist: cryptography (>=45.0.2)
-Requires-Dist: flatdict (>=4.0.0)
 Requires-Dist: jwcrypto (>=1.5.6)
 Requires-Dist: pydash (>=8.0.3)
 Requires-Dist: python-box (>=7.3.0)

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zscaler-sdk-python"
-version = "1.9.13"
+version = "1.9.14"
 description = "Official Python SDK for the Zscaler Products"
 authors = ["Zscaler, Inc. <devrel@zscaler.com>"]
 license = "MIT"
@@ -36,7 +36,6 @@ pyyaml = ">=6.0.0"
 pytz = ">=2024.2"
 python-box = ">=7.3.0"
 python-dateutil = ">=2.9.0"
-flatdict = ">=4.0.0"
 PyJWT = ">=2.10.1"
 jwcrypto = ">=1.5.6"
 aenum = ">=3.1.11"

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/zscaler/__init__.py

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

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/zscaler/config/config_setter.py

@@ -3,9 +3,8 @@ import os
 import logging
 import yaml
 from zscaler.constants import _GLOBAL_YAML_PATH, _LOCAL_YAML_PATH
-from flatdict import FlatDict
 
-from zscaler.helpers import to_snake_case
+from zscaler.helpers import to_snake_case, flatten_dict, unflatten_dict
 
 
 logger = logging.getLogger(__name__)
@@ -74,12 +73,10 @@ class ConfigSetter:
         with no value
         """
         # logger.debug("Pruning configuration to remove empty fields.")
-        flat_current_config = FlatDict(config, delimiter="_")
-        for key in flat_current_config.keys():
-            if flat_current_config.get(key) == "":
-                del flat_current_config[key]
-
-        return flat_current_config.as_dict()
+        flat_current_config = flatten_dict(config, delimiter="_")
+        # Remove empty values
+        flat_current_config = {k: v for k, v in flat_current_config.items() if v != ""}
+        return unflatten_dict(flat_current_config, delimiter="_")
 
     def _update_config(self):
         """
@@ -151,16 +148,19 @@ class ConfigSetter:
     def _apply_config(self, new_config: dict):
         """Apply a config dictionary to the current config, overwriting values"""
         # logger.debug("Applying new configuration settings.")
-        flat_current_client = FlatDict(self._config["client"], delimiter="_")
-        flat_current_testing = FlatDict(self._config["testing"], delimiter="_")
+        flat_current_client = flatten_dict(self._config["client"], delimiter="_")
+        flat_current_testing = flatten_dict(self._config["testing"], delimiter="_")
 
-        flat_new_client = FlatDict(new_config.get("client", {}), delimiter="_")
-        flat_new_testing = FlatDict(new_config.get("testing", {}), delimiter="_")
+        flat_new_client = flatten_dict(new_config.get("client", {}), delimiter="_")
+        flat_new_testing = flatten_dict(new_config.get("testing", {}), delimiter="_")
 
         flat_current_client.update(flat_new_client)
         flat_current_testing.update(flat_new_testing)
 
-        self._config = {"client": flat_current_client.as_dict(), "testing": flat_current_testing.as_dict()}
+        self._config = {
+            "client": unflatten_dict(flat_current_client, delimiter="_"),
+            "testing": unflatten_dict(flat_current_testing, delimiter="_"),
+        }
 
     def _apply_yaml_config(self, path: str):
         """This method applies a YAML configuration to the Zscaler Client Config"""
@@ -181,11 +181,11 @@ class ConfigSetter:
         # logger.debug(f"Applying environment variables for {conf_key} configuration.")
         # Flatten current config and join with underscores
         # (for environment variable format)
-        flattened_config = FlatDict(self._config.get(conf_key, {}), delimiter="_")
+        flattened_config = flatten_dict(self._config.get(conf_key, {}), delimiter="_")
         flattened_keys = flattened_config.keys()
 
         # Create empty result config and populate
-        updated_config = FlatDict({}, delimiter="_")
+        updated_config = {}
 
         # Go through keys and search for it in the environment vars
         # using the format described in the README
@@ -195,4 +195,4 @@ class ConfigSetter:
 
             if env_value is not None:
                 updated_config[key] = env_value
-        self._apply_config({conf_key: updated_config.as_dict()})
+        self._apply_config({conf_key: unflatten_dict(updated_config, delimiter="_")})

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/zscaler/config/config_validator.py

@@ -82,6 +82,11 @@ class ConfigValidator:
         client_id_errors = []
 
         # Ensure client ID is provided
+        if client_id is None:
+            client_id_errors.append(ERROR_MESSAGE_CLIENT_ID_MISSING)
+            logging.warning("Client ID is missing.")
+            return client_id_errors
+
         client_id = client_id.strip().lower()
         if not client_id:
             client_id_errors.append(ERROR_MESSAGE_CLIENT_ID_MISSING)

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/zscaler/helpers.py

@@ -349,6 +349,65 @@ def convert_keys_to_camel_case(data):
         return data
 
 
+def flatten_dict(d, parent_key="", delimiter="_"):
+    """
+    Flatten a nested dictionary into a single-level dictionary with concatenated keys.
+
+    Args:
+        d: Dictionary to flatten
+        parent_key: Prefix for keys (used in recursion)
+        delimiter: String to use between key levels
+
+    Returns:
+        Flattened dictionary
+
+    Examples:
+        >>> flatten_dict({"a": {"b": 1, "c": 2}})
+        {'a_b': 1, 'a_c': 2}
+
+        >>> flatten_dict({"client": {"cache": {"enabled": True}}})
+        {'client_cache_enabled': True}
+    """
+    items = []
+    for k, v in d.items():
+        new_key = f"{parent_key}{delimiter}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, new_key, delimiter).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)
+
+
+def unflatten_dict(d, delimiter="_"):
+    """
+    Unflatten a dictionary with concatenated keys into a nested dictionary.
+
+    Args:
+        d: Flattened dictionary to unflatten
+        delimiter: String delimiter used between key levels
+
+    Returns:
+        Nested dictionary
+
+    Examples:
+        >>> unflatten_dict({"a_b": 1, "a_c": 2})
+        {'a': {'b': 1, 'c': 2}}
+
+        >>> unflatten_dict({"client_cache_enabled": True})
+        {'client': {'cache': {'enabled': True}}}
+    """
+    result = {}
+    for key, value in d.items():
+        parts = key.split(delimiter)
+        current = result
+        for part in parts[:-1]:
+            if part not in current:
+                current[part] = {}
+            current = current[part]
+        current[parts[-1]] = value
+    return result
+
+
 def convert_keys_to_camel_case_selective(data, preserve_snake_case_keys=None):
     """
     Recursively convert keys to camelCase while preserving specific snake_case keys.

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/zscaler/oneapi_client.py

@@ -16,14 +16,17 @@ from zscaler.zdx.zdx_service import ZDXService
 from zscaler.zia.zia_service import ZIAService
 from zscaler.zpa.zpa_service import ZPAService
 from zscaler.zwa.zwa_service import ZWAService
+# from zscaler.binsights.binsights_service import BIService
 from zscaler.zidentity.zidentity_service import ZIdentityService
 from zscaler.zeasm.zeasm_service import ZEASMService
+from zscaler.zaiguard.zaiguard_service import ZGuardService
 from zscaler.zcc.legacy import LegacyZCCClientHelper
 from zscaler.ztw.legacy import LegacyZTWClientHelper
 from zscaler.zdx.legacy import LegacyZDXClientHelper
 from zscaler.zpa.legacy import LegacyZPAClientHelper
 from zscaler.zia.legacy import LegacyZIAClientHelper
 from zscaler.zwa.legacy import LegacyZWAClientHelper
+from zscaler.zaiguard.legacy import LegacyZGuardClientHelper
 
 TLegacy = TypeVar("TLegacy")
 
@@ -40,6 +43,8 @@ class Client:
         zpa_legacy_client: Optional[LegacyZPAClientHelper] = None,
         zia_legacy_client: Optional[LegacyZIAClientHelper] = None,
         zwa_legacy_client: Optional[LegacyZWAClientHelper] = None,
+        zguard_legacy_client: Optional[LegacyZGuardClientHelper] = None,
+        
         use_legacy_client: bool = False,
     ) -> None:
         self.use_legacy_client = use_legacy_client
@@ -49,6 +54,7 @@ class Client:
         self.zpa_legacy_client = zpa_legacy_client
         self.zia_legacy_client = zia_legacy_client
         self.zwa_legacy_client = zwa_legacy_client
+        self.zguard_legacy_client = zguard_legacy_client
 
         # ZCC Legacy client initialization logic
         if use_legacy_client and zcc_legacy_client:
@@ -98,6 +104,14 @@ class Client:
             self.logger.info("Legacy ZTWService client initialized successfully.")
             return
 
+        # ZGuard Legacy client initialization logic
+        if use_legacy_client and zguard_legacy_client:
+            self._config = {}
+            self._request_executor = zguard_legacy_client
+            self.logger = logging.getLogger(__name__)
+            self.logger.info("Legacy ZGuard client initialized successfully.")
+            return
+
         # Assuming user_config is a dictionary or an object with a 'logging' attribute
         logging_config = (
             user_config.get("logging", {}) if isinstance(user_config, dict) else getattr(user_config, "logging", {})
@@ -108,6 +122,7 @@ class Client:
         self.zpa_legacy_client = zpa_legacy_client
         self.zia_legacy_client = zia_legacy_client
         self.zwa_legacy_client = zwa_legacy_client
+        self.zguard_legacy_client = zguard_legacy_client
 
         # Extract enabled and verbose from the logging configuration
         enabled = logging_config.get("enabled", None)
@@ -182,6 +197,7 @@ class Client:
             self.zpa_legacy_client,
             self.zia_legacy_client,
             self.zwa_legacy_client,
+            self.zguard_legacy_client,
         )
         # self.logger.debug("Request executor initialized.")
 
@@ -195,7 +211,9 @@ class Client:
         self._zidentity = None
         self._zeasm = None
         self._zins = None  # Z-Insights (GraphQL Analytics API)
+        # self._bi = None
         # self.logger.debug("Client initialized successfully.")
+        self._zguard = None
 
     def authenticate(self):
         """
@@ -265,13 +283,27 @@ class Client:
         if self._zidentity is None:
             self._zidentity = ZIdentityService(self._request_executor)
         return self._zidentity
-    
+
+    # @property
+    # def bi(self):
+    #     if self._bi is None:
+    #         self._bi = BIService(self._request_executor)
+    #     return self._bi
+
     @property
     def zeasm(self):
         if self._zeasm is None:
             self._zeasm = ZEASMService(self._request_executor)
         return self._zeasm
 
+    @property
+    def zguard(self):
+        if self.use_legacy_client:
+            return self._require_legacy_client("ZGuard", self.zguard_legacy_client)
+        if self._zguard is None:
+            self._zguard = ZGuardService(self._request_executor)
+        return self._zguard
+
     @property
     def zinsights(self):
         """
@@ -553,3 +585,27 @@ class LegacyZWAClient(Client):
             request_executor_impl=request_executor_impl,
         )
         super().__init__(config, zwa_legacy_client=legacy_helper, use_legacy_client=True)
+
+
+class LegacyZGuardClient(Client):
+    def __init__(
+        self,
+        config: dict = {},
+    ):
+        api_key = config.get("api_key", os.getenv("AIGUARD_API_KEY"))
+        cloud = config.get("cloud", os.getenv("AIGUARD_CLOUD", "us1"))
+        timeout = config.get("timeout", 240)
+        cache = config.get("cache", None)
+        fail_safe = config.get("failSafe", None)
+        request_executor_impl = config.get("requestExecutor", None)
+        
+        # Initialize the LegacyZGuardClientHelper with the extracted parameters
+        legacy_helper = LegacyZGuardClientHelper(
+            api_key=api_key,
+            cloud=cloud,
+            timeout=timeout,
+            cache=cache,
+            fail_safe=fail_safe,
+            request_executor_impl=request_executor_impl,
+        )
+        super().__init__(config, zguard_legacy_client=legacy_helper, use_legacy_client=True)

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/zscaler/oneapi_http_client.py

@@ -10,6 +10,7 @@ from zscaler.zdx.legacy import LegacyZDXClientHelper
 from zscaler.zpa.legacy import LegacyZPAClientHelper
 from zscaler.zia.legacy import LegacyZIAClientHelper
 from zscaler.zwa.legacy import LegacyZWAClientHelper
+from zscaler.zaiguard.legacy import LegacyZGuardClientHelper
 from urllib.parse import urlparse
 
 logger = logging.getLogger(__name__)
@@ -32,6 +33,7 @@ class HTTPClient:
         zpa_legacy_client: Optional[LegacyZPAClientHelper] = None,
         zia_legacy_client: Optional[LegacyZIAClientHelper] = None,
         zwa_legacy_client: Optional[LegacyZWAClientHelper] = None,
+        zguard_legacy_client: Optional[LegacyZGuardClientHelper] = None,
     ) -> None:
 
         # Get headers from Request Executor
@@ -42,7 +44,8 @@ class HTTPClient:
         self.zpa_legacy_client: Optional[LegacyZPAClientHelper] = zpa_legacy_client
         self.zia_legacy_client: Optional[LegacyZIAClientHelper] = zia_legacy_client
         self.zwa_legacy_client: Optional[LegacyZWAClientHelper] = zwa_legacy_client
-
+        self.zguard_legacy_client: Optional[LegacyZGuardClientHelper] = zguard_legacy_client
+        
         # Determine if legacy clients are enabled
         self.use_zcc_legacy_client: bool = zcc_legacy_client is not None
         self.use_ztw_legacy_client: bool = ztw_legacy_client is not None
@@ -50,7 +53,8 @@ class HTTPClient:
         self.use_zpa_legacy_client: bool = zpa_legacy_client is not None
         self.use_zia_legacy_client: bool = zia_legacy_client is not None
         self.use_zwa_legacy_client: bool = zwa_legacy_client is not None
-
+        self.use_zguard_legacy_client: bool = zguard_legacy_client is not None
+        
         # Set timeout for all HTTP requests
         request_timeout: Optional[int] = http_config.get("requestTimeout", None)
         self._timeout: Optional[int] = request_timeout if request_timeout and request_timeout > 0 else None
@@ -282,6 +286,28 @@ class HTTPClient:
                     }
                 )
 
+            elif self.use_zguard_legacy_client:
+                parsed_url = urlparse(request["url"])
+                path = parsed_url.path
+                logger.debug(f"Sending request via AIGuard legacy client. Path: {path}")
+
+                response = self.zguard_legacy_client.send(
+                    method=request["method"],
+                    path=path,
+                    params=request["params"],
+                    json=request.get("json") or request.get("data"),
+                )
+
+                logger.debug(f"AIGuard Legacy Client Response: {response}")
+
+                if response is None:
+                    error_msg = f"AIGuard Legacy client returned None for path: {path}"
+                    logger.error(error_msg)
+                    return (None, ValueError(error_msg))
+
+                # For AIGuard, the response is just the requests.Response object
+                # No need to update params as authentication is already handled
+
             else:
                 # Standard session
                 if self._session:

{zscaler_sdk_python-1.9.13 → zscaler_sdk_python-1.9.14}/zscaler/request_executor.py

@@ -19,6 +19,7 @@ from zscaler.zdx.legacy import LegacyZDXClientHelper
 from zscaler.zpa.legacy import LegacyZPAClientHelper
 from zscaler.zia.legacy import LegacyZIAClientHelper
 from zscaler.zwa.legacy import LegacyZWAClientHelper
+from zscaler.zaiguard.legacy import LegacyZGuardClientHelper
 
 logger = logging.getLogger('zscaler-sdk-python')
 
@@ -41,6 +42,7 @@ class RequestExecutor:
         zpa_legacy_client: LegacyZPAClientHelper = None,
         zia_legacy_client: LegacyZIAClientHelper = None,
         zwa_legacy_client: LegacyZWAClientHelper = None,
+        zguard_legacy_client: LegacyZGuardClientHelper = None,
     ):
         """
         Constructor for Request Executor object for Zscaler SDK Client.
@@ -56,6 +58,7 @@ class RequestExecutor:
         self.zpa_legacy_client = zpa_legacy_client
         self.zia_legacy_client = zia_legacy_client
         self.zwa_legacy_client = zwa_legacy_client
+        self.zguard_legacy_client = zguard_legacy_client
 
         self.use_legacy_client = (
             zpa_legacy_client is not None
@@ -64,6 +67,7 @@ class RequestExecutor:
             or zcc_legacy_client is not None
             or ztw_legacy_client is not None
             or zdx_legacy_client is not None
+            or zguard_legacy_client is not None
         )
 
         # Validate and set request timeout
@@ -123,6 +127,7 @@ class RequestExecutor:
             zpa_legacy_client=self.zpa_legacy_client,
             zia_legacy_client=self.zia_legacy_client,
             zwa_legacy_client=self.zwa_legacy_client,
+            zguard_legacy_client=self.zguard_legacy_client,
         )
 
         exceptions.raise_exception = self._config["client"].get("raiseException", False)
@@ -178,6 +183,8 @@ class RequestExecutor:
             return "zcc"
         elif "/zdx" in url:
             return "zdx"
+        # elif "/bi" in url:
+        #     return "bi"
         elif "/zwa" in url:
             return "zwa"
         elif "/zpa" in url or "/mgmtconfig" in url:
@@ -190,6 +197,8 @@ class RequestExecutor:
             return "zeasm"
         elif "/zins" in url:
             return "zins"
+        elif "/v1/detection" in url or (self.zguard_legacy_client and "/v1/" in url):
+            return "zguard"
         if self.use_legacy_client:
             url = self.remove_oneapi_endpoint_prefix(url)
             # Recheck for service type after removing the prefix
@@ -252,6 +261,8 @@ class RequestExecutor:
                 base_url = self.zdx_legacy_client.get_base_url(endpoint)
             elif service_type == "zwa":
                 base_url = self.zwa_legacy_client.get_base_url(endpoint)
+            elif service_type == "zguard":
+                base_url = self.zguard_legacy_client.get_base_url(endpoint)
             else:
                 base_url = self.get_base_url(endpoint)
         else:

zscaler_sdk_python-1.9.14/zscaler/zaiguard/__init__.py

@@ -0,0 +1,15 @@
+"""
+Copyright (c) 2023, Zscaler Inc.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+"""