catocli 2.1.2__py3-none-any.whl → 2.1.4__py3-none-any.whl

catocli/Utils/clidriver.py

@@ -49,18 +49,18 @@ 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_xdr import query_xdr_parse
-from ..parsers.query_policy import query_policy_parse
 from ..parsers.query_groups import query_groups_parse
+from ..parsers.query_policy import query_policy_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_site import mutation_site_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_groups import mutation_groups_parse
 from ..parsers.mutation_hardware import mutation_hardware_parse
+from ..parsers.mutation_groups import mutation_groups_parse
+from ..parsers.mutation_policy import mutation_policy_parse
 from ..parsers.mutation_enterpriseDirectory import mutation_enterpriseDirectory_parse
 
 def show_version_info(args, configuration=None):
@@ -85,15 +85,6 @@ def show_version_info(args, configuration=None):
         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 {}
         
 def get_configuration(skip_api_key=False):
     configuration = Configuration()
@@ -143,6 +134,8 @@ parser = argparse.ArgumentParser(prog='catocli', usage='%(prog)s <operationType>
 parser.add_argument('--version', action='version', version=catocli.__version__)
 parser.add_argument('-H', '--header', action='append', dest='headers', help='Add custom headers in "Key: Value" format. Can be used multiple times.')
 parser.add_argument('--headers-file', dest='headers_file', help='Load headers from a file. Each line should contain a header in "Key: Value" format.')
+parser.add_argument('-n', '--stream-events', dest='stream_events', help='Send events over network to host:port TCP')
+parser.add_argument('-z', '--sentinel', dest='sentinel', help='Send events to Sentinel customerid:sharedkey')
 subparsers = parser.add_subparsers()
 
 # Version command - enhanced with update checking
@@ -190,18 +183,18 @@ 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_xdr_parser = query_xdr_parse(query_subparsers)
-query_policy_parser = query_policy_parse(query_subparsers)
 query_groups_parser = query_groups_parse(query_subparsers)
+query_policy_parser = query_policy_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_site_parser = mutation_site_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_groups_parser = mutation_groups_parse(mutation_subparsers)
 mutation_hardware_parser = mutation_hardware_parse(mutation_subparsers)
+mutation_groups_parser = mutation_groups_parse(mutation_subparsers)
+mutation_policy_parser = mutation_policy_parse(mutation_subparsers)
 mutation_enterpriseDirectory_parser = mutation_enterpriseDirectory_parse(mutation_subparsers)
 
 
@@ -285,7 +278,14 @@ def main(args=None):
             print(response)
         else:
             if response!=None:
-                print(json.dumps(response[0], sort_keys=True, indent=4))
+                # Check if this is CSV output
+                if (isinstance(response, list) and len(response) > 0 and 
+                    isinstance(response[0], dict) and "__csv_output__" in response[0]):
+                    # Print CSV output directly without JSON formatting
+                    print(response[0]["__csv_output__"], end='')
+                else:
+                    # Standard JSON output
+                    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

catocli/Utils/cliutils.py

@@ -0,0 +1,165 @@
+#!/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 {}
+
+
+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