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

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

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

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

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

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

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

zscaler_sdk_python-1.2.3/zscaler/helpers.py

@@ -0,0 +1,289 @@
+"""
+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",
+        "deleteDHCPOption121Routes": "delete_dhcp_option121_routes",
+        "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",
+        "disableParallelIpv4AndIPv6": "disable_parallel_ipv4_and_ipv6",
+        "computeDeviceGroupsForZDX ": "compute_device_groups_for_zdx",
+        "logoutZCCForZDXService": "logout_zcc_for_zdx_service",
+        "enableZpaDR": "enable_zpa_dr",
+        "ziaRSAPubKeyName": "zia_rsa_pub_key_name",
+        "ziaRSAPubKey": "zia_rsa_pub_key",
+        "zpaRSAPubKeyName": "zpa_rsa_pub_key_name",
+        "zpaRSAPubKey": "zpa_rsa_pub_key",
+        "truncate_large_udpdns_response": "truncateLargeUDPDNSResponse",
+        "enableZCCRevert": "enable_zcc_revert",
+        "enableZiaDR": "enable_zia_dr",
+        "purge_kerberos_preferred_dc_cache": "purgeKerberosPreferredDCCache"
+    }
+
+    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",
+        "disable_parallel_ipv4_and_ipv6": "disableParallelIpv4AndIPv6",
+        "compute_device_groups_for_zdx": "computeDeviceGroupsForZDX",
+        "logout_zcc_for_zdx_service ": "logoutZCCForZDXService",
+        "enable_zpa_dr": "enableZpaDR",
+        "zia_rsa_pub_key_name": "ziaRSAPubKeyName",
+        "zia_rsa_pub_key": "ziaRSAPubKey",
+        "zpa_rsa_pub_key_name": "zpaRSAPubKeyName",
+        "zpa_rsa_pub_key": "zpaRSAPubKey",
+        "truncateLargeUDPDNSResponse": "truncate_large_udpdns_response",
+        "enable_zcc_revert": "enableZCCRevert",
+        "delete_dhcp_option121_routes": "deleteDHCPOption121Routes",
+        "enableZiaDR": "enable_zia_dr",
+        "purgeKerberosPreferredDCCache": "purge_kerberos_preferred_dc_cache"
+    }
+
+    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.1 → zscaler_sdk_python-1.2.3}/zscaler/oneapi_response.py

@@ -78,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)
@@ -178,46 +166,6 @@ 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):
         """
@@ -225,6 +173,14 @@ class ZscalerAPIResponse:
         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):
@@ -236,48 +192,6 @@ class ZscalerAPIResponse:
         """
         return self._has_next()
 
-    # 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
-
     def next(self):
         if not self.has_next():
             raise StopIteration("No more pages available.")
@@ -297,39 +211,6 @@ class ZscalerAPIResponse:
         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):
         if not self._has_next():
             logger.debug("No more pages to fetch")
@@ -360,13 +241,6 @@ class ZscalerAPIResponse:
         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.1 → zscaler_sdk_python-1.2.3}/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)

{zscaler_sdk_python-1.2.1 → zscaler_sdk_python-1.2.3}/zscaler/utils.py

@@ -26,7 +26,7 @@ import time
 from typing import Dict, Optional
 from urllib.parse import urlencode
 from datetime import datetime as dt
-
+from functools import wraps
 import pytz
 from box import Box, BoxList
 from dateutil import parser
@@ -783,6 +783,67 @@ def format_url(base_string):
     """
     return "".join([line.strip() for line in base_string.splitlines()])
 
+def zcc_param_mapper(func):
+    @wraps(func)
+    def wrapper(self, *args, **kwargs):
+        query_params = kwargs.get("query_params", {}) or {}
+        mapped_params = {}
+
+        # Normalize and map os_types
+        if "os_type" in query_params:
+            os_raw = query_params["os_type"]
+            if isinstance(os_raw, str):
+                os_raw = [os_raw]  # ✅ support single string value
+
+            mapped = [
+                str(zcc_param_map["os"].get(os_type.lower()))
+                for os_type in os_raw
+                if zcc_param_map["os"].get(os_type.lower())
+            ]
+            if not mapped:
+                raise ValueError("Invalid `os_type` provided.")
+            mapped_params["osType"] = ",".join(mapped)
+
+        # Normalize and map os_types
+        if "device_type" in query_params:
+            os_raw = query_params["device_type"]
+            if isinstance(os_raw, str):
+                os_raw = [os_raw]  # ✅ support single string value
+
+            mapped = [
+                str(zcc_param_map["os"].get(os_type.lower()))
+                for os_type in os_raw
+                if zcc_param_map["os"].get(os_type.lower())
+            ]
+            if not mapped:
+                raise ValueError("Invalid `device_type` provided.")
+            mapped_params["deviceType"] = ",".join(mapped)
+
+        # Normalize and map registration_types
+        if "registration_types" in query_params:
+            reg_raw = query_params["registration_types"]
+            if isinstance(reg_raw, str):
+                reg_raw = [reg_raw]
+
+            mapped = [
+                str(zcc_param_map["reg_type"].get(rt.lower()))
+                for rt in reg_raw
+                if zcc_param_map["reg_type"].get(rt.lower())
+            ]
+            if not mapped:
+                raise ValueError("Invalid `registration_types` provided.")
+            mapped_params["registrationTypes"] = ",".join(mapped)
+
+        # Drop user-friendly keys
+        query_params.pop("os_types", None)
+        query_params.pop("registration_types", None)
+
+        # Merge in mapped numeric params
+        query_params.update(mapped_params)
+        kwargs["query_params"] = query_params
+
+        return func(self, *args, **kwargs)
+    return wrapper
 
 # Maps ZCC numeric os_type and registration_type arguments to a human-readable string
 zcc_param_map = {