catocli 2.1.1__py3-none-any.whl → 2.1.3__py3-none-any.whl

catocli/Utils/clidriver.py

@@ -5,7 +5,7 @@ import json
 import catocli
 from graphql_client import Configuration
 from graphql_client.api_client import ApiException
-from ..parsers.parserApiClient import get_help
+from ..parsers.customParserApiClient import get_help
 from .profile_manager import get_profile_manager
 from .version_checker import check_for_updates, force_check_updates
 import traceback
@@ -20,110 +20,104 @@ from ..parsers.raw import raw_parse
 from ..parsers.custom import custom_parse
 from ..parsers.custom_private import private_parse
 from ..parsers.query_siteLocation import query_siteLocation_parse
-from ..parsers.mutation_accountManagement import mutation_accountManagement_parse
-from ..parsers.mutation_admin import mutation_admin_parse
-from ..parsers.mutation_container import mutation_container_parse
-from ..parsers.mutation_groups import mutation_groups_parse
-from ..parsers.mutation_hardware import mutation_hardware_parse
-from ..parsers.mutation_policy import mutation_policy_parse
-from ..parsers.mutation_sandbox import mutation_sandbox_parse
-from ..parsers.mutation_site import mutation_site_parse
-from ..parsers.mutation_sites import mutation_sites_parse
-from ..parsers.mutation_xdr import mutation_xdr_parse
-from ..parsers.query_accountBySubdomain import query_accountBySubdomain_parse
-from ..parsers.query_accountManagement import query_accountManagement_parse
+from ..parsers.query_socketPortMetrics import query_socketPortMetrics_parse
+from ..parsers.query_socketPortMetricsTimeSeries import query_socketPortMetricsTimeSeries_parse
 from ..parsers.query_accountMetrics import query_accountMetrics_parse
-from ..parsers.query_accountRoles import query_accountRoles_parse
 from ..parsers.query_accountSnapshot import query_accountSnapshot_parse
-from ..parsers.query_admin import query_admin_parse
-from ..parsers.query_admins import query_admins_parse
-from ..parsers.query_appStats import query_appStats_parse
-from ..parsers.query_appStatsTimeSeries import query_appStatsTimeSeries_parse
+from ..parsers.query_eventsFeed import query_eventsFeed_parse
+from ..parsers.query_hardwareManagement import query_hardwareManagement_parse
+from ..parsers.query_events import query_events_parse
+from ..parsers.query_eventsTimeSeries import query_eventsTimeSeries_parse
 from ..parsers.query_auditFeed import query_auditFeed_parse
-from ..parsers.query_catalogs import query_catalogs_parse
 from ..parsers.query_container import query_container_parse
-from ..parsers.query_devices import query_devices_parse
+from ..parsers.query_admins import query_admins_parse
 from ..parsers.query_entityLookup import query_entityLookup_parse
-from ..parsers.query_events import query_events_parse
-from ..parsers.query_eventsFeed import query_eventsFeed_parse
-from ..parsers.query_eventsTimeSeries import query_eventsTimeSeries_parse
-from ..parsers.query_groups import query_groups_parse
-from ..parsers.query_hardware import query_hardware_parse
-from ..parsers.query_hardwareManagement import query_hardwareManagement_parse
-from ..parsers.query_licensing import query_licensing_parse
-from ..parsers.query_policy import query_policy_parse
-from ..parsers.query_popLocations import query_popLocations_parse
+from ..parsers.query_accountRoles import query_accountRoles_parse
+from ..parsers.query_accountBySubdomain import query_accountBySubdomain_parse
+from ..parsers.query_subDomains import query_subDomains_parse
+from ..parsers.query_appStats import query_appStats_parse
+from ..parsers.query_appStatsTimeSeries import query_appStatsTimeSeries_parse
+from ..parsers.query_admin import query_admin_parse
+from ..parsers.query_servicePrincipalAdmin import query_servicePrincipalAdmin_parse
+from ..parsers.query_accountManagement import query_accountManagement_parse
 from ..parsers.query_sandbox import query_sandbox_parse
+from ..parsers.query_popLocations import query_popLocations_parse
+from ..parsers.query_licensing import query_licensing_parse
+from ..parsers.query_hardware import query_hardware_parse
+from ..parsers.query_enterpriseDirectory import query_enterpriseDirectory_parse
+from ..parsers.query_devices import query_devices_parse
+from ..parsers.query_catalogs import query_catalogs_parse
 from ..parsers.query_site import query_site_parse
-from ..parsers.query_socketPortMetrics import query_socketPortMetrics_parse
-from ..parsers.query_socketPortMetricsTimeSeries import query_socketPortMetricsTimeSeries_parse
-from ..parsers.query_subDomains import query_subDomains_parse
 from ..parsers.query_xdr import query_xdr_parse
+from ..parsers.query_policy import query_policy_parse
+from ..parsers.query_groups import query_groups_parse
+from ..parsers.mutation_xdr import mutation_xdr_parse
+from ..parsers.mutation_site import mutation_site_parse
+from ..parsers.mutation_sites import mutation_sites_parse
+from ..parsers.mutation_container import mutation_container_parse
+from ..parsers.mutation_admin import mutation_admin_parse
+from ..parsers.mutation_policy import mutation_policy_parse
+from ..parsers.mutation_accountManagement import mutation_accountManagement_parse
+from ..parsers.mutation_sandbox import mutation_sandbox_parse
+from ..parsers.mutation_hardware import mutation_hardware_parse
+from ..parsers.mutation_groups import mutation_groups_parse
+from ..parsers.mutation_enterpriseDirectory import mutation_enterpriseDirectory_parse
 
 def show_version_info(args, configuration=None):
-	print(f"catocli version {catocli.__version__}")
-	
-	if not args.current_only:
-		if args.check_updates:
-			# Force check for updates
-			is_newer, latest_version, source = force_check_updates()
-		else:
-			# Regular check (uses cache)
-			is_newer, latest_version, source = check_for_updates(show_if_available=False)
-		
-		if latest_version:
-			if is_newer:
-				print(f"Latest version: {latest_version} (from {source}) - UPDATE AVAILABLE!")
-				print()
-				print("To upgrade, run:")
-				print("pip install --upgrade catocli")
-			else:
-				print(f"Latest version: {latest_version} (from {source}) - You are up to date!")
-		else:
-			print("Unable to check for updates (check your internet connection)")
-	return [{"success": True, "current_version": catocli.__version__, "latest_version": latest_version if not args.current_only else None}]
-
-def load_private_settings():
-	# Load private settings from ~/.cato/settings.json
-	settings_file = os.path.expanduser("~/.cato/settings.json")
-	try:
-		with open(settings_file, 'r') as f:
-			return json.load(f)
-	except (FileNotFoundError, json.JSONDecodeError):
-		return {}
-	
+    print(f"catocli version {catocli.__version__}")
+    
+    if not args.current_only:
+        if args.check_updates:
+            # Force check for updates
+            is_newer, latest_version, source = force_check_updates()
+        else:
+            # Regular check (uses cache)
+            is_newer, latest_version, source = check_for_updates(show_if_available=False)
+        
+        if latest_version:
+            if is_newer:
+                print(f"Latest version: {latest_version} (from {source}) - UPDATE AVAILABLE!")
+                print()
+                print("To upgrade, run:")
+                print("pip install --upgrade catocli")
+            else:
+                print(f"Latest version: {latest_version} (from {source}) - You are up to date!")
+        else:
+            print("Unable to check for updates (check your internet connection)")
+    return [{"success": True, "current_version": catocli.__version__, "latest_version": latest_version if not args.current_only else None}]
+        
 def get_configuration(skip_api_key=False):
-	configuration = Configuration()
-	configuration.verify_ssl = False
-	configuration.debug = CATO_DEBUG
-	configuration.version = "{}".format(catocli.__version__)
-	
-	# Try to migrate from environment variables first
-	profile_manager.migrate_from_environment()
-	
-	# Get credentials from profile
-	credentials = profile_manager.get_credentials()
-	if not credentials:
-		print("No Cato CLI profile configured.")
-		print("Run 'catocli configure set' to set up your credentials.")
-		exit(1)
+    configuration = Configuration()
+    configuration.verify_ssl = False
+    configuration.debug = CATO_DEBUG
+    configuration.version = "{}".format(catocli.__version__)
+    
+    # Try to migrate from environment variables first
+    profile_manager.migrate_from_environment()
+    
+    # Get credentials from profile
+    credentials = profile_manager.get_credentials()
+    if not credentials:
+        print("No Cato CLI profile configured.")
+        print("Run 'catocli configure set' to set up your credentials.")
+        exit(1)
 
-	if not credentials.get('cato_token') or not credentials.get('account_id'):
-		profile_name = profile_manager.get_current_profile()
-		print(f"Profile '{profile_name}' is missing required credentials.")
-		print(f"Run 'catocli configure set --profile {profile_name}' to update your credentials.")
-		exit(1)
-	
-	# Use standard endpoint from profile for regular API calls
-	configuration.host = credentials['endpoint']
-		
-	# Only set API key if not using custom headers file
-	# (Private settings are handled separately in createPrivateRequest)
-	if not skip_api_key:
-		configuration.api_key["x-api-key"] = credentials['cato_token']
-	configuration.accountID = credentials['account_id']
-	
-	return configuration
+    if not credentials.get('cato_token') or not credentials.get('account_id'):
+        profile_name = profile_manager.get_current_profile()
+        print(f"Profile '{profile_name}' is missing required credentials.")
+        print(f"Run 'catocli configure set --profile {profile_name}' to update your credentials.")
+        exit(1)
+    
+    # Use standard endpoint from profile for regular API calls
+    configuration.host = credentials['endpoint']
+        
+    # Only set API key if not using custom headers file
+    # (Private settings are handled separately in createPrivateRequest)
+    if not skip_api_key:
+        configuration.api_key["x-api-key"] = credentials['cato_token']
+    configuration.accountID = credentials['account_id']
+    
+    return configuration
 
 defaultReadmeStr = """
 The Cato CLI is a command-line interface tool designed to simplify the management and automation of Cato Networks’ configurations and operations. 
@@ -158,139 +152,141 @@ query_siteLocation_parser = query_siteLocation_parse(query_subparsers)
 mutation_parser = subparsers.add_parser('mutation', help='Mutation', usage='catocli mutation <operationName> [options]')
 mutation_subparsers = mutation_parser.add_subparsers(description='valid subcommands', help='additional help')
 
-mutation_accountManagement_parser = mutation_accountManagement_parse(mutation_subparsers)
-mutation_admin_parser = mutation_admin_parse(mutation_subparsers)
-mutation_container_parser = mutation_container_parse(mutation_subparsers)
-mutation_groups_parser = mutation_groups_parse(mutation_subparsers)
-mutation_hardware_parser = mutation_hardware_parse(mutation_subparsers)
-mutation_policy_parser = mutation_policy_parse(mutation_subparsers)
-mutation_sandbox_parser = mutation_sandbox_parse(mutation_subparsers)
-mutation_site_parser = mutation_site_parse(mutation_subparsers)
-mutation_sites_parser = mutation_sites_parse(mutation_subparsers)
-mutation_xdr_parser = mutation_xdr_parse(mutation_subparsers)
-query_accountBySubdomain_parser = query_accountBySubdomain_parse(query_subparsers)
-query_accountManagement_parser = query_accountManagement_parse(query_subparsers)
+query_socketPortMetrics_parser = query_socketPortMetrics_parse(query_subparsers)
+query_socketPortMetricsTimeSeries_parser = query_socketPortMetricsTimeSeries_parse(query_subparsers)
 query_accountMetrics_parser = query_accountMetrics_parse(query_subparsers)
-query_accountRoles_parser = query_accountRoles_parse(query_subparsers)
 query_accountSnapshot_parser = query_accountSnapshot_parse(query_subparsers)
-query_admin_parser = query_admin_parse(query_subparsers)
-query_admins_parser = query_admins_parse(query_subparsers)
-query_appStats_parser = query_appStats_parse(query_subparsers)
-query_appStatsTimeSeries_parser = query_appStatsTimeSeries_parse(query_subparsers)
+query_eventsFeed_parser = query_eventsFeed_parse(query_subparsers)
+query_hardwareManagement_parser = query_hardwareManagement_parse(query_subparsers)
+query_events_parser = query_events_parse(query_subparsers)
+query_eventsTimeSeries_parser = query_eventsTimeSeries_parse(query_subparsers)
 query_auditFeed_parser = query_auditFeed_parse(query_subparsers)
-query_catalogs_parser = query_catalogs_parse(query_subparsers)
 query_container_parser = query_container_parse(query_subparsers)
-query_devices_parser = query_devices_parse(query_subparsers)
+query_admins_parser = query_admins_parse(query_subparsers)
 query_entityLookup_parser = query_entityLookup_parse(query_subparsers)
-query_events_parser = query_events_parse(query_subparsers)
-query_eventsFeed_parser = query_eventsFeed_parse(query_subparsers)
-query_eventsTimeSeries_parser = query_eventsTimeSeries_parse(query_subparsers)
-query_groups_parser = query_groups_parse(query_subparsers)
-query_hardware_parser = query_hardware_parse(query_subparsers)
-query_hardwareManagement_parser = query_hardwareManagement_parse(query_subparsers)
-query_licensing_parser = query_licensing_parse(query_subparsers)
-query_policy_parser = query_policy_parse(query_subparsers)
-query_popLocations_parser = query_popLocations_parse(query_subparsers)
+query_accountRoles_parser = query_accountRoles_parse(query_subparsers)
+query_accountBySubdomain_parser = query_accountBySubdomain_parse(query_subparsers)
+query_subDomains_parser = query_subDomains_parse(query_subparsers)
+query_appStats_parser = query_appStats_parse(query_subparsers)
+query_appStatsTimeSeries_parser = query_appStatsTimeSeries_parse(query_subparsers)
+query_admin_parser = query_admin_parse(query_subparsers)
+query_servicePrincipalAdmin_parser = query_servicePrincipalAdmin_parse(query_subparsers)
+query_accountManagement_parser = query_accountManagement_parse(query_subparsers)
 query_sandbox_parser = query_sandbox_parse(query_subparsers)
+query_popLocations_parser = query_popLocations_parse(query_subparsers)
+query_licensing_parser = query_licensing_parse(query_subparsers)
+query_hardware_parser = query_hardware_parse(query_subparsers)
+query_enterpriseDirectory_parser = query_enterpriseDirectory_parse(query_subparsers)
+query_devices_parser = query_devices_parse(query_subparsers)
+query_catalogs_parser = query_catalogs_parse(query_subparsers)
 query_site_parser = query_site_parse(query_subparsers)
-query_socketPortMetrics_parser = query_socketPortMetrics_parse(query_subparsers)
-query_socketPortMetricsTimeSeries_parser = query_socketPortMetricsTimeSeries_parse(query_subparsers)
-query_subDomains_parser = query_subDomains_parse(query_subparsers)
 query_xdr_parser = query_xdr_parse(query_subparsers)
+query_policy_parser = query_policy_parse(query_subparsers)
+query_groups_parser = query_groups_parse(query_subparsers)
+mutation_xdr_parser = mutation_xdr_parse(mutation_subparsers)
+mutation_site_parser = mutation_site_parse(mutation_subparsers)
+mutation_sites_parser = mutation_sites_parse(mutation_subparsers)
+mutation_container_parser = mutation_container_parse(mutation_subparsers)
+mutation_admin_parser = mutation_admin_parse(mutation_subparsers)
+mutation_policy_parser = mutation_policy_parse(mutation_subparsers)
+mutation_accountManagement_parser = mutation_accountManagement_parse(mutation_subparsers)
+mutation_sandbox_parser = mutation_sandbox_parse(mutation_subparsers)
+mutation_hardware_parser = mutation_hardware_parse(mutation_subparsers)
+mutation_groups_parser = mutation_groups_parse(mutation_subparsers)
+mutation_enterpriseDirectory_parser = mutation_enterpriseDirectory_parse(mutation_subparsers)
 
 
 def parse_headers(header_strings):
-	headers = {}
-	if header_strings:
-		for header_string in header_strings:
-			if ':' not in header_string:
-				print(f"ERROR: Invalid header format '{header_string}'. Use 'Key: Value' format.")
-				exit(1)
-			key, value = header_string.split(':', 1)
-			headers[key.strip()] = value.strip()
-	return headers
+    headers = {}
+    if header_strings:
+        for header_string in header_strings:
+            if ':' not in header_string:
+                print(f"ERROR: Invalid header format '{header_string}'. Use 'Key: Value' format.")
+                exit(1)
+            key, value = header_string.split(':', 1)
+            headers[key.strip()] = value.strip()
+    return headers
 
 def parse_headers_from_file(file_path):
-	headers = {}
-	try:
-		with open(file_path, 'r') as f:
-			for line_num, line in enumerate(f, 1):
-				line = line.strip()
-				if not line or line.startswith('#'):
-					# Skip empty lines and comments
-					continue
-				if ':' not in line:
-					print(f"ERROR: Invalid header format in {file_path} at line {line_num}: '{line}'. Use 'Key: Value' format.")
-					exit(1)
-				key, value = line.split(':', 1)
-				headers[key.strip()] = value.strip()
-	except FileNotFoundError:
-		print(f"ERROR: Headers file '{file_path}' not found.")
-		exit(1)
-	except IOError as e:
-		print(f"ERROR: Could not read headers file '{file_path}': {e}")
-		exit(1)
-	return headers
+    headers = {}
+    try:
+        with open(file_path, 'r') as f:
+            for line_num, line in enumerate(f, 1):
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                if ':' not in line:
+                    print(f"ERROR: Invalid header format in {file_path} at line {line_num}: '{line}'. Use 'Key: Value' format.")
+                    exit(1)
+                key, value = line.split(':', 1)
+                headers[key.strip()] = value.strip()
+    except FileNotFoundError:
+        print(f"ERROR: Headers file '{file_path}' not found.")
+        exit(1)
+    except IOError as e:
+        print(f"ERROR: Could not read headers file '{file_path}': {e}")
+        exit(1)
+    return headers
 
 def main(args=None):
-	# Check if no arguments provided or help is requested
-	if args is None:
-		args = sys.argv[1:]
+    # Check if no arguments provided or help is requested
+    if args is None:
+        args = sys.argv[1:]
 
-	# Show version check when displaying help or when no command specified
-	if not args or '-h' in args or '--help' in args:
-		# Check for updates in background (non-blocking)
-		try:
-			check_for_updates(show_if_available=True)
-		except Exception:
-			# Don't let version check interfere with CLI operation
-			pass
+    # Show version check when displaying help or when no command specified
+    if not args or '-h' in args or '--help' in args:
+        # Check for updates in background (non-blocking)
+        try:
+            check_for_updates(show_if_available=True)
+        except Exception:
+            # Don't let version check interfere with CLI operation
+            pass
 
-	args = parser.parse_args(args=args)
-	try:
-		# Skip authentication for configure commands
-		if hasattr(args, 'func') and hasattr(args.func, '__module__') and 'configure' in str(args.func.__module__):
-			response = args.func(args, None)
-		else:
-			# Check if using headers file to determine if we should skip API key
-			# Note: Private settings should NOT affect regular API calls - only private commands
-			using_headers_file = hasattr(args, 'headers_file') and args.headers_file
-			
-			# Get configuration from profiles
-			configuration = get_configuration(skip_api_key=using_headers_file)
-			
-			# Parse custom headers if provided
-			custom_headers = {}
-			if hasattr(args, 'headers') and args.headers:
-				custom_headers.update(parse_headers(args.headers))
-			if hasattr(args, 'headers_file') and args.headers_file:
-				custom_headers.update(parse_headers_from_file(args.headers_file))
-			if custom_headers:
-				configuration.custom_headers.update(custom_headers)
-			# Handle account ID override (applies to all commands except raw)
-			if args.func.__name__ not in ["createRawRequest"]:
-				if hasattr(args, 'accountID') and args.accountID is not None:
-					# Command line override takes precedence
-					configuration.accountID = args.accountID
-				# Otherwise use the account ID from the profile (already set in get_configuration)
-			response = args.func(args, configuration)
+    args = parser.parse_args(args=args)
+    try:
+        # Skip authentication for configure commands
+        if hasattr(args, 'func') and hasattr(args.func, '__module__') and 'configure' in str(args.func.__module__):
+            response = args.func(args, None)
+        else:
+            # Check if using headers file to determine if we should skip API key
+            # Note: Private settings should NOT affect regular API calls - only private commands
+            using_headers_file = hasattr(args, 'headers_file') and args.headers_file
+            
+            # Get configuration from profiles
+            configuration = get_configuration(skip_api_key=using_headers_file)
+            
+            # Parse custom headers if provided
+            custom_headers = {}
+            if hasattr(args, 'headers') and args.headers:
+                custom_headers.update(parse_headers(args.headers))
+            if hasattr(args, 'headers_file') and args.headers_file:
+                custom_headers.update(parse_headers_from_file(args.headers_file))
+            if custom_headers:
+                configuration.custom_headers.update(custom_headers)
+            # Handle account ID override (applies to all commands except raw)
+            if args.func.__name__ not in ["createRawRequest"]:
+                if hasattr(args, 'accountID') and args.accountID is not None:
+                    # Command line override takes precedence
+                    configuration.accountID = args.accountID
+                # Otherwise use the account ID from the profile (already set in get_configuration)
+            response = args.func(args, configuration)
 
-		if type(response) == ApiException:
-			print("ERROR! Status code: {}".format(response.status))
-			print(response)
-		else:
-			if response!=None:
-				print(json.dumps(response[0], sort_keys=True, indent=4))
-	except KeyboardInterrupt:
-		print('Operation cancelled by user (Ctrl+C).')
-		exit(130)  # Standard exit code for SIGINT
-	except Exception as e:
-		if isinstance(e, AttributeError):
-			print('Missing arguments. Usage: catocli <operation> -h')
-			if args.v==True:
-				print('ERROR: ',e)
-				traceback.print_exc()
-		else:
-			print('ERROR: ',e)
-			traceback.print_exc()
-	exit(1)
+        if type(response) == ApiException:
+            print("ERROR! Status code: {}".format(response.status))
+            print(response)
+        else:
+            if response!=None:
+                print(json.dumps(response[0], sort_keys=True, indent=4))
+    except KeyboardInterrupt:
+        print('Operation cancelled by user (Ctrl+C).')
+        exit(130)  # Standard exit code for SIGINT
+    except Exception as e:
+        if isinstance(e, AttributeError):
+            print('Missing arguments. Usage: catocli <operation> -h')
+            if args.v==True:
+                print('ERROR: ',e)
+                traceback.print_exc()
+        else:
+            print('ERROR: ',e)
+            traceback.print_exc()
+    exit(1)

catocli/Utils/cliutils.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""
+General CLI utilities for catocli
+
+This module contains general-purpose utility functions used across the catocli
+package, including settings loading and configuration management.
+"""
+
+import os
+import json
+
+
+# Import for resource handling
+try:
+    # Python 3.9+
+    from importlib.resources import files
+    def get_package_resource(package, filename):
+        return files(package).joinpath(filename).read_text(encoding='utf-8')
+except ImportError:
+    try:
+        # Python 3.7-3.8
+        from importlib.resources import read_text
+        def get_package_resource(package, filename):
+            return read_text(package, filename, encoding='utf-8')
+    except ImportError:
+        try:
+            # Fallback to pkg_resources
+            import pkg_resources
+            def get_package_resource(package, filename):
+                return pkg_resources.resource_string(package, filename).decode('utf-8')
+        except ImportError:
+            # Final fallback - no package resources available
+            def get_package_resource(package, filename):
+                raise ImportError("No resource handling module available")
+
+
+def load_cli_settings():
+    """
+    Load clisettings.json from multiple possible locations:
+    1. Package resource (for installed packages)
+    2. Repository location (for development)
+    
+    Returns:
+        dict: The loaded settings or default settings if loading fails
+    """
+    settings_locations = [
+        # Try package resource first (for installed packages)
+        lambda: json.loads(get_package_resource('catocli', 'clisettings.json')),
+        # Try repository location (for development)
+        lambda: json.load(open(os.path.join(os.path.dirname(__file__), '../../clisettings.json'), 'r', encoding='utf-8'))
+    ]
+    
+    for i, load_func in enumerate(settings_locations):
+        try:
+            settings = load_func()
+            if settings:
+                return settings
+        except (FileNotFoundError, json.JSONDecodeError, ImportError, OSError, ModuleNotFoundError) as e:
+            # Continue to next location
+            continue
+    
+    # If all locations fail, return default settings for socket export
+    return {
+        "export_by_socket_type": {
+            "SOCKET_X1500": True,
+            "SOCKET_X1600": True,
+            "SOCKET_X1600_LTE": True,
+            "SOCKET_X1700": True
+        },
+        "default_socket_interface_map": {
+            "SOCKET_X1500": "LAN1",
+            "SOCKET_X1600": "INT_5",
+            "SOCKET_X1600_LTE": "INT_5",
+            "SOCKET_X1700": "INT_3"
+        }
+    }
+
+
+def get_cli_settings_path():
+    """
+    Get the path to the CLI settings file, trying different locations.
+    
+    Returns:
+        str or None: Path to the settings file if found, None otherwise
+    """
+    possible_paths = [
+        # Repository location (for development)
+        os.path.join(os.path.dirname(__file__), '../../clisettings.json'),
+        # Current directory
+        os.path.join(os.getcwd(), 'clisettings.json'),
+    ]
+    
+    for path in possible_paths:
+        if os.path.exists(path):
+            return path
+    
+    return None
+
+
+def load_json_file(file_path, encoding='utf-8'):
+    """
+    Load a JSON file with error handling.
+    
+    Args:
+        file_path (str): Path to the JSON file
+        encoding (str): File encoding (default: utf-8)
+    
+    Returns:
+        dict or None: The loaded JSON data, or None if loading fails
+    """
+    try:
+        with open(file_path, 'r', encoding=encoding) as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+        return None
+
+
+def save_json_file(data, file_path, encoding='utf-8', indent=2):
+    """
+    Save data to a JSON file with error handling.
+    
+    Args:
+        data: Data to save
+        file_path (str): Path to save the JSON file
+        encoding (str): File encoding (default: utf-8)
+        indent (int): JSON indentation (default: 2)
+    
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    try:
+        # Ensure the directory exists
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        with open(file_path, 'w', encoding=encoding) as f:
+            json.dump(data, f, indent=indent, ensure_ascii=False)
+        return True
+    except (OSError, TypeError, ValueError) as e:
+        return False
+
+
+def load_private_settings():
+    """
+    Load private settings from ~/.cato/settings.json in an OS-compatible way.
+    
+    This function constructs the path to ~/.cato/settings.json using os.path methods
+    for cross-platform compatibility (Windows, Mac, Linux).
+    
+    Returns:
+        dict: The privateCommands section from the settings file, or empty dict if not found
+    """
+    # Use os.path.join for OS-compatible path construction
+    cato_dir = os.path.join(os.path.expanduser("~"), ".cato")
+    settings_file = os.path.join(cato_dir, "settings.json")
+    
+    try:
+        with open(settings_file, 'r', encoding='utf-8') as f:
+            settings = json.load(f)
+            return settings.get('privateCommands', {})
+    except (FileNotFoundError, json.JSONDecodeError, KeyError, OSError):
+        return {}
+
+
+def ensure_directory_exists(directory_path):
+    """
+    Ensure a directory exists, creating it if necessary.
+    
+    Args:
+        directory_path (str): Path to the directory
+        
+    Returns:
+        bool: True if directory exists or was created successfully
+    """
+    try:
+        os.makedirs(directory_path, exist_ok=True)
+        return True
+    except OSError:
+        return False

catocli/__init__.py

@@ -1,2 +1,2 @@
-__version__ = "2.1.1"
+__version__ = "2.1.3"
 __cato_host__ = "https://api.catonetworks.com/api/v1/graphql2"

catocli/parsers/custom/customLib.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from graphql_client.api.call_api import ApiClient, CallApi
 from graphql_client.api_client import ApiException
 import logging
-from ..parserApiClient import validateArgs
+from ..customParserApiClient import validateArgs
 
 def entityTypeList(args, configuration):
     params = vars(args)