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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zscaler-sdk-python
-Version: 1.2.0
+Version: 1.2.2
 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.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zscaler-sdk-python"
-version = "1.2.0"
+version = "1.2.2"
 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.2}/zscaler/__init__.py

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

zscaler_sdk_python-1.2.2/zscaler/helpers.py

@@ -0,0 +1,264 @@
+"""
+Module contains different helper functions.
+Module is independent from any zscaler modules.
+"""
+
+import re
+
+
+def to_snake_case(string):
+    """
+    Converts camelCase or PascalCase to snake_case.
+    Applies known field-specific corrections first.
+    """
+    FIELD_EXCEPTIONS = {
+        "predefinedADPControls": "predefined_adp_controls",
+        "surrogateIP": "surrogate_ip",
+        "surrogateIPEnforcedForKnownBrowsers": "surrogate_ip_enforced_for_known_browsers",
+        "capturePCAP": "capture_pcap",
+        "internalIpRange": "internal_ip_range",
+        "startIPAddress": "start_ip_address",
+        "endIPAddress": "end_ip_address",
+        "minTLSVersion": "min_tls_version",
+        "minClientTLSVersion": "min_client_tls_version",
+        "minServerTLSVersion": "min_server_tls_version",
+        "pacWithStaticIPs": "pac_with_static_ips",
+        "primaryGW": "primary_gw",
+        "secondaryGW": "secondary_gw",
+        "greTunnelIP": "gre_tunnel_ip",
+        "tunID": "tun_id",
+        "isIncompleteDRConfig": "is_incomplete_dr_config",
+        "nameL10nTag": "name_l10n_tag",
+        "isNameL10nTag": "is_name_l10n_tag",
+        "routableIP": "routable_ip",
+        "validSSLCertificate": "valid_ssl_certificate",
+        "ecVMs": "ec_vms",
+        "ipV6Enabled": "ipv6_enabled",
+        "emailIds": "email_ids",
+        "showEUN": "show_eun",
+        "showEUNATP": "show_eunatp",
+        "enableCIPACompliance": "enable_cipa_compliance",
+        "enablePOEPrompt": "enable_poe_prompt",
+        "cookieStealingPCAPEnabled": "cookie_stealing_pcap_enabled",
+        "alertForUnknownOrSuspiciousC2Traffic": "alert_for_unknown_or_suspicious_c2_traffic",
+        "enableIPv6DnsResolutionOnTransparentProxy": "enable_ipv6_dns_resolution_on_transparent_proxy",
+        "enableEvaluatePolicyOnGlobalSSLBypass": "enable_evaluate_policy_on_global_ssl_bypass",
+        "dnsResolutionOnTransparentProxyIPv6ExemptApps": "dns_resolution_on_transparent_proxy_ipv6_exempt_apps",
+        "dnsResolutionOnTransparentProxyIPv6UrlCategories": "dns_resolution_on_transparent_proxy_ipv6_url_categories",
+        "dnsResolutionOnTransparentProxyIPv6Apps": "dns_resolution_on_transparent_proxy_ipv6_apps",
+        "enableIPv6DnsOptimizationOnAllTransparentProxy": "enable_ipv6_dns_optimization_on_all_transparent_proxy",
+        "dnsResolutionOnTransparentProxyIPv6ExemptUrlCategories": "dns_resolution_on_transparent_proxy_ipv6_exempt_url_categories",
+        "endPointDLPLogType": "end_point_dlp_log_type",
+        "emailDLPLogType": "email_dlp_log_type",
+        "extranetDNSList": "extranet_dns_list",
+        "primaryDNSServer": "primary_dns_server",
+        "secondaryDNSServer": "secondary_dns_server",
+        
+        # ZCC Edge Case Attributes
+        "enableUDPTransportSelection": "enable_udp_transport_selection",
+        "interceptZIATrafficAllAdapters": "intercept_zia_traffic_all_adapters",
+        "enablePortBasedZPAFilter": "enable_port_based_zpa_filter",
+        "addAppBypassToVPNGateway": "add_app_bypass_to_vpn_gateway",
+        "showVPNTunNotification": "show_vpn_tun_notification",
+        "enableSetProxyOnVPNAdapters": "enable_set_proxy_on_vpn_adapters",
+        "disableDNSRouteExclusion": "disable_dns_route_exclusion",
+        "enableReactUI": "enable_react_ui",
+        "ziaGlobalDbUrlForDR": "zia_global_db_url_for_dr",
+        "useDefaultAdapterForDNS": "use_default_adapter_for_dns",
+        "enablePublicAPI": "enable_public_api",
+        "launchReactUIbyDefault": "launch_react_u_iby_default",
+        "addZDXServiceEntitlement": "add_zdx_service_entitlement",
+        "computeDeviceGroupsForZIA": "compute_device_groups_for_zia",
+        "computeDeviceGroupsForZPA": "compute_device_groups_for_zpa",
+        "computeDeviceGroupsForZAD": "compute_device_groups_for_zad",
+        "computeDeviceGroupsForZAD": "compute_device_groups_for_zad",
+        "deleteDHCPOption121RoutesVisibility": "delete_dhcp_option121_routes_visibility",
+        "enableOneIDAdminMigrationChanges": "enable_one_id_admin_migration_changes",
+        "purgeKerberosPreferredDCCacheVisibility": "purge_kerberos_preferred_dc_cache_visibility",
+        "slowRolloutZCC": "slow_rollout_zcc",
+        "supportMultiplePWLPostures": "support_multiple_pwl_postures",
+        "truncateLargeUDPDNSResponseVisibility": "truncate_large_udpdns_response_visibility",
+        "enforceSplitDNSVisibility": "enforce_split_dns_visibility",
+        "zccSyntheticIPRangeVisibility": "zcc_synthetic_ip_range_visibility",
+        "enableSetProxyOnVPNAdaptersVisibility": "enable_set_proxy_on_vpn_adapters_visibility",
+        "customMTUForZpaVisibility": "custom_mtu_for_zpa_visibility",
+        "flowLoggerZCCBlockedTrafficVisibility": "flow_logger_zcc_blocked_traffic_visibility",
+        "postureCrowdStrikeZTAScoreVisibilityForLinux": "posture_crowd_strike_zta_score_visibility_for_linux",
+        "flowLoggerVPNTunnelTypeVisibility": "flow_logger_vpn_tunnel_type_visibility",
+        "flowLoggerVPNTypeVisibility": "flow_logger_vpn_type_visibility",
+        "flowLoggerZPATypeVisibility": "flow_logger_zpa_type_visibility",
+        "useDefaultAdapterForDNSVisibility": "use_default_adapter_for_dns_visibility",
+        "useCustomDNS": "use_custom_dns",
+        "notificationForZPAReauthVisibility": "notification_for_zpa_reauth_visibility",
+        "crowdStrikeZTAScoreVisibility": "crowd_strike_zta_score_visibility",
+        "hideDTLSSupportSettings": "hide_dtls_support_settings",
+        "dynamicZPAServiceEdgeAssignmenttVisibility": "dynamic_zpa_service_edge_assignmentt_visibility",
+        "domainInclusionExclusionForDNSRequestVisibility": "domain_inclusion_exclusion_for_dns_request_visibility",
+        "overrideATCmdByPolicyVisibility": "override_at_cmd_by_policy_visibility",
+        "windowsAPCaptivePortalDetectionVisibility": "windows_ap_captive_portal_detection_visibility",
+        "windowsAPEnableFailOpenVisibility": "windows_ap_enable_fail_open_visibility",
+        "enableOneIDPhase2Changes": "enable_one_id_phase2_changes",
+        "linuxRPMBuildVisibility": "linux_rpm_build_visibility",
+        "crowdStrikeZTAOsScoreVisibility": "crowd_strike_zta_os_score_visibility",
+        "crowdStrikeZTASensorConfigScoreVisibility": "crowd_strike_zta_sensor_config_score_visibility",
+        "enableZCCFailCloseSettingsForSEMode": "enable_zcc_fail_close_settings_for_se_mode",
+        "defaultProtocolForZPA": "default_protocol_for_zpa",
+        "tunnelTwoForiOSDevices": "tunnel_two_fori_os_devices",
+        "prioritizeIPv4OverIpv6": "prioritize_ipv4_over_ipv6",
+    }
+
+    if string in FIELD_EXCEPTIONS:
+        return FIELD_EXCEPTIONS[string]
+
+    # Generic fallback logic
+    string = re.sub(r"(?<!^)(?=[A-Z])", "_", string).lower()
+    return string.replace("__", "_").strip("_")
+
+
+def to_lower_camel_case(string):
+    """
+    Converts snake_case to camelCase with support for known edge-case field mappings.
+
+    Examples:
+        "internal_ip_range" -> "internalIpRange"
+        "surrogate_ip"      -> "surrogateIP"
+        "capture_pcap"      -> "capturePCAP"
+    """
+
+    FIELD_EXCEPTIONS = {
+        "predefined_adp_controls": "predefinedADPControls",
+        "surrogate_ip": "surrogateIP",
+        "internal_ip_range": "internalIpRange",
+        "start_ip_address": "startIPAddress",
+        "end_ip_address": "endIPAddress",
+        "capture_pcap": "capturePCAP",
+        "min_tls_version": "minTLSVersion",
+        "min_client_tls_version": "minClientTLSVersion",
+        "min_server_tls_version": "minServerTLSVersion",
+        "pac_with_static_ips": "pacWithStaticIPs",
+        "primary_gw": "primaryGW",
+        "secondary_gw": "secondaryGW",
+        "greTunnel_ip": "greTunnelIP",
+        "tun_id": "tunID",
+        "is_incomplete_dr_config": "isIncompleteDRConfig",
+        "name_l10n_tag": "nameL10nTag",
+        "is_name_l10n_tag": "isNameL10nTag",
+        "routable_ip": "routableIP",
+        "valid_ssl_certificate": "validSSLCertificate",
+        "ec_vms": "ecVMs",
+        "ipv6_enabled": "ipV6Enabled",
+        "email_ids": "emailIds",
+        "show_eun": "showEUN",
+        "show_eunatp": "showEUNATP",
+        "enable_cipa_compliance": "enableCIPACompliance",
+        "enable_poe_prompt": "enablePOEPrompt",
+        "cookie_stealing_pcap_enabled": "cookieStealingPCAPEnabled",
+        "alert_for_unknown_or_suspicious_c2_traffic": "alertForUnknownOrSuspiciousC2Traffic",
+        "enable_ipv6_dns_resolution_on_transparent_proxy": "enableIPv6DnsResolutionOnTransparentProxy",
+        "enable_evaluate_policy_on_global_ssl_bypass": "enableEvaluatePolicyOnGlobalSSLBypass",
+        "dns_resolution_on_transparent_proxy_ipv6_exempt_apps": "dnsResolutionOnTransparentProxyIPv6ExemptApps",
+        "dns_resolution_on_transparent_proxy_ipv6_url_categories": "dnsResolutionOnTransparentProxyIPv6UrlCategories",
+        "dns_resolution_on_transparent_proxy_ipv6_apps": "dnsResolutionOnTransparentProxyIPv6Apps",
+        "enable_ipv6_dns_optimization_on_all_transparent_proxy": "enableIPv6DnsOptimizationOnAllTransparentProxy",
+        "dns_resolution_on_transparent_proxy_ipv6_exempt_url_categories": "dnsResolutionOnTransparentProxyIPv6ExemptUrlCategories",
+        "end_point_dlp_log_type": "endPointDLPLogType",
+        "email_dlp_log_type": "emailDLPLogType",
+        "extranet_dns_list": "extranetDNSList",
+        "primary_dns_server": "primaryDNSServer",
+        "secondary_dns_server": "secondaryDNSServer",
+        
+        # ZCC Edge Case Attributes
+        "enable_udp_transport_selection": "enableUDPTransportSelection",
+        "intercept_zia_traffic_all_adapters": "interceptZIATrafficAllAdapters",
+        "enable_port_based_zpa_filter": "enablePortBasedZPAFilter",
+        "add_app_bypass_to_vpn_gateway": "addAppBypassToVPNGateway",
+        "show_vpn_tun_notification": "showVPNTunNotification",
+        "enable_set_proxy_on_vpn_adapters": "enableSetProxyOnVPNAdapters",
+        "disable_dns_route_exclusion": "disableDNSRouteExclusion",
+        "enable_react_ui": "enableReactUI",
+        "zia_global_db_url_for_dr": "ziaGlobalDbUrlForDR",
+        "use_default_adapter_for_dns": "useDefaultAdapterForDNS",
+        "enable_public_api": "enablePublicAPI",
+        "launch_react_u_iby_default": "launchReactUIbyDefault",
+        "add_zdx_service_entitlement": "addZDXServiceEntitlement",
+        "compute_device_groups_for_zia": "computeDeviceGroupsForZIA",
+        "compute_device_groups_for_zpa": "computeDeviceGroupsForZPA",
+        "compute_device_groups_for_zad": "computeDeviceGroupsForZAD",
+        "delete_dhcp_option121_routes_visibility": "deleteDHCPOption121RoutesVisibility",
+        "enable_one_id_admin_migration_changes": "enableOneIDAdminMigrationChanges",
+        "purge_kerberos_preferred_dc_cache_visibility": "purgeKerberosPreferredDCCacheVisibility",
+        "slow_rollout_zcc": "slowRolloutZCC",
+        "support_multiple_pwl_postures": "supportMultiplePWLPostures",
+        "truncate_large_udpdns_response_visibility": "truncateLargeUDPDNSResponseVisibility",
+        "enforce_split_dns_visibility": "enforceSplitDNSVisibility",
+        "zcc_synthetic_ip_range_visibility": "zccSyntheticIPRangeVisibility",
+        "enable_set_proxy_on_vpn_adapters_visibility": "enableSetProxyOnVPNAdaptersVisibility",
+        "custom_mtu_for_zpa_visibility": "customMTUForZpaVisibility",
+        "flow_logger_zcc_blocked_traffic_visibility": "flowLoggerZCCBlockedTrafficVisibility",
+        "posture_crowd_strike_zta_score_visibility_for_linux": "postureCrowdStrikeZTAScoreVisibilityForLinux",
+        "flow_logger_vpn_tunnel_type_visibility": "flowLoggerVPNTunnelTypeVisibility",
+        "flow_logger_vpn_type_visibility": "flowLoggerVPNTypeVisibility",
+        "flow_logger_zpa_type_visibility": "flowLoggerZPATypeVisibility",
+        "use_default_adapter_for_dns_visibility": "useDefaultAdapterForDNSVisibility",
+        "use_custom_dns": "useCustomDNS",
+        "notification_for_zpa_reauth_visibility": "notificationForZPAReauthVisibility",
+        "crowd_strike_zta_score_visibility": "crowdStrikeZTAScoreVisibility",
+        "hide_dtls_support_settings": "hideDTLSSupportSettings",
+        "dynamic_zpa_service_edge_assignmentt_visibility": "dynamicZPAServiceEdgeAssignmenttVisibility",
+        "domain_inclusion_exclusion_for_dns_request_visibility": "domainInclusionExclusionForDNSRequestVisibility",
+        "override_at_cmd_by_policy_visibility": "overrideATCmdByPolicyVisibility",
+        "windows_ap_captive_portal_detection_visibility": "windowsAPCaptivePortalDetectionVisibility",
+        "windows_ap_enable_fail_open_visibility": "windowsAPEnableFailOpenVisibility",
+        "enable_one_id_phase2_changes": "enableOneIDPhase2Changes",
+        "linux_rpm_build_visibility": "linuxRPMBuildVisibility",
+        "crowd_strike_zta_os_score_visibility": "crowdStrikeZTAOsScoreVisibility",
+        "crowd_strike_zta_sensor_config_score_visibility": "crowdStrikeZTASensorConfigScoreVisibility",
+        "enable_zcc_fail_close_settings_for_se_mode": "enableZCCFailCloseSettingsForSEMode",
+        "default_protocol_for_zpa": "defaultProtocolForZPA",
+        "tunnelTwoForiOSDevices": "tunnel_two_fori_os_devices",
+        "prioritize_ipv4_over_ipv6": "prioritizeIPv4OverIpv6",
+        
+    }
+
+    if string in FIELD_EXCEPTIONS:
+        return FIELD_EXCEPTIONS[string]
+
+    if not string or "_" not in string:
+        return string
+
+    components = string.split("_")
+    converted = []
+
+    for i, comp in enumerate(components):
+        lower = comp.lower()
+        if i == 0:
+            converted.append(lower)
+        else:
+            converted.append(comp.capitalize())
+
+    return "".join(converted)
+
+
+def convert_keys_to_snake_case(data):
+    """
+    Convert all keys in a dictionary or list to snake_case.
+    """
+    if isinstance(data, dict):
+        return {to_snake_case(k): convert_keys_to_snake_case(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [convert_keys_to_snake_case(item) for item in data]
+    else:
+        return data
+
+
+def convert_keys_to_camel_case(data):
+    """
+    Recursively convert all keys in a dictionary or list to camelCase.
+    Handles nested lists and dictionaries.
+    """
+    if isinstance(data, dict):
+        return {to_lower_camel_case(k): convert_keys_to_camel_case(v) for k, v in data.items()}
+    elif isinstance(data, list):
+        return [convert_keys_to_camel_case(item) for item in data]
+    else:
+        return data

zscaler_sdk_python-1.2.2/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.2}/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.2}/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,
@@ -80,19 +78,7 @@ class ZscalerAPIResponse:
 
         if res_details:
             content_type = res_details.headers.get("Content-Type", "").lower()
-            #     if "application/json" in content_type:
-            #         self._build_json_response(response_body)
-            #     else:
-            #         # Attempt JSON parse, else store as text
-            #         try:
-            #             self._build_json_response(response_body)
-            #         except json.JSONDecodeError:
-            #             self._body = response_body
-            # else:
-            #     try:
-            #         self._build_json_response(response_body)
-            #     except json.JSONDecodeError:
-            #         self._body = response_body
+
             if "application/json" in content_type:
                 try:
                     self._build_json_response(response_body)
@@ -180,13 +166,21 @@ class ZscalerAPIResponse:
 
         self._items_fetched += len(self._list)
         self._pages_fetched += 1
-
+    
     def get_results(self):
         """
         Returns the current page of results.
         The initial call to the API returns only one page.
         """
         logger.debug("Fetching current page results")
+
+        if self._service_type.upper() == "ZCC" and self._type:
+            try:
+                return [self._type(item) for item in self._list if isinstance(item, dict)]
+            except Exception as wrap_error:
+                logger.warning(f"Failed to wrap results with {self._type}: {wrap_error}")
+                return self._list
+
         return self._list
 
     def has_next(self):
@@ -199,35 +193,28 @@ class ZscalerAPIResponse:
         return self._has_next()
 
     def next(self):
-        """
-        Fetch the next page of results if available.
+        if not self.has_next():
+            raise StopIteration("No more pages available.")
 
-        Returns:
-            tuple: (list of items, error)
+        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
 
-        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)
 
     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,20 +235,12 @@ 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
-        # if self._max_items is not None and self._items_fetched >= self._max_items:
-        #     logger.debug("Reached max items limit: %d", self._max_items)
-        #     return False
-        # if self._max_pages is not None and self._pages_fetched >= self._max_pages:
-        #     logger.debug("Reached max pages limit: %d", self._max_pages)
-        #     return False
 
         if self._service_type == "ZPA":
             # More pages if current page < total_pages

{zscaler_sdk_python-1.2.0 → zscaler_sdk_python-1.2.2}/zscaler/request_executor.py

@@ -14,8 +14,9 @@ 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.logger import setup_logging  # ✅ Import here
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger('zscaler-sdk-python')
 
 
 class RequestExecutor:
@@ -75,6 +76,13 @@ class RequestExecutor:
         self._config = config
         self._cache = cache
 
+        # ✅ Setup logging based on config flags
+        # log_config = self._config["client"].get("logging", {})
+        # setup_logging(
+        #     enabled=log_config.get("enabled", False),
+        #     verbose=log_config.get("verbose", False),
+        # )
+
         # Retrieve cloud, service, and customer ID (optional)
         self.cloud = self._config["client"].get("cloud", "production").lower()
         self.sandbox_cloud = self._config["client"].get("sandboxCloud", "").lower()
@@ -462,7 +470,7 @@ class RequestExecutor:
         req_timeout = self._request_timeout
 
         if req_timeout > 0 and (current_req_start_time - request_start_time) > req_timeout:
-            logger.error("Request Timeout exceeded.")
+            logger.warning("Request Timeout exceeded.")
             return None, None, None, Exception("Request Timeout exceeded.")
 
         response, error = self._http_client.send_request(request)