mantatech-sdk 0.5b0.dev65__py3-none-any.whl

manta/cli/commands/sdk_module.py

@@ -0,0 +1,516 @@
+"""SDK module management commands."""
+
+from pathlib import Path
+from typing import Optional
+
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+from rich.tree import Tree
+
+from .base_handler import BaseSDKHandler
+
+
+class SDKModuleHandler(BaseSDKHandler):
+    """Handle module-related SDK commands."""
+
+    def add_subparsers(self, parent_parser):
+        """Add module command subparsers."""
+        self.parser = parent_parser  # Store parser reference
+        subparsers = parent_parser.add_subparsers(
+            dest="module_command", help="Module commands"
+        )
+
+        # List modules command
+        list_parser = subparsers.add_parser("list", help="List all user modules")
+
+        # List module IDs command
+        list_ids_parser = subparsers.add_parser("list-ids", help="List module IDs only")
+
+        # Show module command
+        show_parser = subparsers.add_parser(
+            "show", help="Show detailed module information"
+        )
+        show_parser.add_argument("module_id", help="Module ID to show")
+
+        # Upload/Push module command (using 'push' for consistency)
+        push_parser = subparsers.add_parser("push", help="Upload a module from file")
+        push_parser.add_argument("module_file", help="Path to module file")
+        push_parser.add_argument("--module-id", help="Optional module ID")
+
+        # Update module command
+        update_parser = subparsers.add_parser(
+            "update", help="Update an existing module"
+        )
+        update_parser.add_argument("module_id", help="Module ID to update")
+        update_parser.add_argument("module_file", help="Path to new module file")
+
+        # Delete module command
+        delete_parser = subparsers.add_parser("delete", help="Delete a module")
+        delete_parser.add_argument("module_id", help="Module ID to delete")
+        delete_parser.add_argument(
+            "--force", action="store_true", help="Skip confirmation"
+        )
+
+        # Download/Get module command (using 'get' for consistency)
+        get_parser = subparsers.add_parser("get", help="Download a module to file")
+        get_parser.add_argument("module_id", help="Module ID to download")
+        get_parser.add_argument("--output", help="Output file or directory path")
+
+        # Add profile override to all subcommands
+        for parser in [
+            list_parser,
+            list_ids_parser,
+            show_parser,
+            push_parser,
+            update_parser,
+            delete_parser,
+            get_parser,
+        ]:
+            parser.add_argument("--profile", help="Use specific profile")
+
+    def handle(self, args) -> int:
+        """Handle module commands."""
+        if not args.module_command:
+            if hasattr(self, "parser"):
+                self.parser.print_help()
+            return 0  # Return 0 for help display
+
+        if args.module_command == "list":
+            return self.list_modules()
+        elif args.module_command == "list-ids":
+            return self.list_module_ids()
+        elif args.module_command == "show":
+            return self.show_module(args.module_id)
+        elif args.module_command == "push":
+            return self.upload_module(
+                args.module_file, getattr(args, "module_id", None)
+            )
+        elif args.module_command == "update":
+            return self.update_module(args.module_id, args.module_file)
+        elif args.module_command == "delete":
+            return self.delete_module(args.module_id, getattr(args, "force", False))
+        elif args.module_command == "get":
+            return self.download_module(args.module_id, getattr(args, "output", None))
+        else:
+            self.print_error(f"Unknown module command: {args.module_command}")
+            return 1
+
+    def list_modules(self) -> int:
+        """List all modules for the user."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                modules = await api.stream_and_fetch_modules()
+                return modules
+
+            modules = self._run_with_progress(run, "Fetching modules...")
+
+            if modules is None:
+                return 1
+
+            if not modules:
+                self.print("No modules found.")
+                return 0
+
+            # Display modules
+            table = Table(title="User Modules")
+            table.add_column("Module ID", style="cyan")
+            table.add_column("Name", style="blue")
+            table.add_column("Type", style="green")
+            table.add_column("Size", style="magenta")
+            table.add_column("Created", style="yellow")
+
+            for module in modules:
+                # UserAPI returns Module objects (not dicts, not protos)
+                module_id = (
+                    module.module_id
+                    if hasattr(module, "module_id") and module.module_id
+                    else ""
+                )
+                name = (
+                    module.name
+                    if hasattr(module, "name") and module.name
+                    else "Unknown"
+                )
+                image = (
+                    module.image
+                    if hasattr(module, "image") and module.image
+                    else "Python"
+                )
+
+                # Get size from python_files if available
+                data_size = 0
+                if hasattr(module, "python_files") and module.python_files:
+                    # Sum the size of all files
+                    data_size = sum(
+                        len(content) for content in module.python_files.values()
+                    )
+
+                table.add_row(
+                    module_id,
+                    name,
+                    image,
+                    self._format_size(data_size),
+                    "N/A",  # Created timestamp not available
+                )
+
+            self.console.print(table)
+
+            return 0
+
+        except Exception as e:
+            self.print_error(f"Failed to list modules: {e}")
+            return 1
+
+    def list_module_ids(self) -> int:
+        """List module IDs only."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                return await api.list_module_ids()
+
+            module_ids = self._run_with_progress(run, "Fetching module IDs...")
+
+            if module_ids is None:
+                return 1
+
+            if not module_ids:
+                self.print("No modules found.")
+                return 0
+
+            self.print(f"Found {len(module_ids)} modules:")
+            for module_id in module_ids:
+                self.print(f"  {module_id}")
+
+            return 0
+
+        except Exception as e:
+            self.print_error(f"Failed to list module IDs: {e}")
+            return 1
+
+    def show_module(self, module_id: str) -> int:
+        """Show detailed module information."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                return await api.get_module(module_id)
+
+            module = self._run_with_progress(run, "Fetching module details...")
+
+            if module is None:
+                return 1
+
+            # Display module details
+            # UserAPI returns Module objects
+            name = module.name if hasattr(module, "name") and module.name else "Unknown"
+            image = (
+                module.image if hasattr(module, "image") and module.image else "Python"
+            )
+
+            # Get size from python_files if available
+            data_size = 0
+            if hasattr(module, "python_files") and module.python_files:
+                data_size = sum(
+                    len(content) for content in module.python_files.values()
+                )
+
+            panel = Panel.fit(
+                f"[cyan]Module ID:[/cyan] {module_id}\n"
+                f"[cyan]Name:[/cyan] {name}\n"
+                f"[cyan]Type:[/cyan] {image}\n"
+                f"[cyan]Size:[/cyan] {self._format_size(data_size)}\n"
+                f"[cyan]Created:[/cyan] N/A",
+                title=f"Module: {module_id}",
+            )
+            self.console.print(panel)
+
+            return 0
+
+        except Exception as e:
+            self.print_error(f"Failed to get module details: {e}")
+            return 1
+
+    def upload_module(self, module_file: str, module_id: Optional[str] = None) -> int:
+        """Upload a module from file."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+            # Import Module class
+            from manta.apis.module import Module
+
+            # Validate file path
+            module_path = Path(module_file)
+            if not module_path.exists():
+                self.print_error(f"Module file not found: {module_file}")
+                return 1
+
+            # Get image name from user if not provided
+            default_image = "python:3.9-slim"
+            image = Prompt.ask("Container image", default=default_image)
+
+            # Create Module object
+            module = Module(
+                python_program=module_path,
+                image=image,
+                name=module_path.stem if module_path.is_file() else module_path.name,
+            )
+
+            async def run():
+                return await api.send_module(module)
+
+            result_id = self._run_with_progress(
+                run, f"Uploading module from {module_file}..."
+            )
+
+            if result_id is None:
+                return 1
+
+            self.print_success(f"Module uploaded successfully with ID: {result_id}")
+            return 0
+
+        except FileNotFoundError:
+            self.print_error(f"Module file not found: {module_file}")
+            return 1
+        except PermissionError:
+            self.print_error(f"Permission denied reading file: {module_file}")
+            return 1
+        except Exception as e:
+            self.print_error(f"Failed to upload module: {e}")
+            return 1
+
+    def update_module(self, module_id: str, module_file: str) -> int:
+        """Update an existing module."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+            # Import Module class
+            from manta.apis.module import Module
+
+            # Validate module_id parameter
+            if not module_id:
+                self.print_error("Module ID is required for update operation")
+                return 1
+
+            # Validate file path
+            module_path = Path(module_file)
+            if not module_path.exists():
+                self.print_error(f"Module file not found: {module_file}")
+                return 1
+
+            # First verify the module exists by trying to get it
+            async def check_module_exists():
+                try:
+                    return await api.get_module(module_id)
+                except Exception:
+                    return None
+
+            existing_module = self._run_with_progress(
+                check_module_exists, "Checking if module exists..."
+            )
+
+            if existing_module is None:
+                # Error during fetch, not just missing module
+                return 1
+
+            if not existing_module:
+                self.print_error(f"Module with ID '{module_id}' not found")
+                return 1
+
+            # Get image name - use existing image as default or prompt for new one
+            existing_image = getattr(existing_module, "image", "python:3.9-slim")
+            image = Prompt.ask("Container image", default=existing_image)
+
+            # Create updated Module object
+            module = Module(
+                python_program=module_path,
+                image=image,
+                name=module_path.stem if module_path.is_file() else module_path.name,
+            )
+
+            async def run():
+                return await api.update_module(module, module_id)
+
+            result_id = self._run_with_progress(run, f"Updating module {module_id}...")
+
+            if result_id is None:
+                return 1
+
+            self.print_success(f"Module updated successfully: {result_id}")
+            return 0
+
+        except FileNotFoundError:
+            self.print_error(f"Module file not found: {module_file}")
+            return 1
+        except PermissionError:
+            self.print_error(f"Permission denied reading file: {module_file}")
+            return 1
+        except Exception as e:
+            self.print_error(f"Failed to update module: {e}")
+            return 1
+
+    def delete_module(self, module_id: str, force: bool = False) -> int:
+        """Delete a module."""
+        if not force:
+            confirm = Confirm.ask(
+                f"Are you sure you want to delete module '{module_id}'?"
+            )
+            if not confirm:
+                self.print("Operation cancelled.")
+                return 0
+
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                return await api.remove_module(module_id)
+
+            result = self._run_with_progress(run, "Deleting module...")
+
+            if result is None:
+                return 1
+
+            self.print_success("Module deleted successfully")
+            return 0
+
+        except Exception as e:
+            self.print_error(f"Failed to delete module: {e}")
+            return 1
+
+    def download_module(self, module_id: str, output_file: Optional[str] = None) -> int:
+        """Download a module to file."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+            # Validate module_id parameter
+            if not module_id:
+                self.print_error("Module ID is required for download operation")
+                return 1
+
+            # Fetch module from server
+            async def run():
+                return await api.get_module(module_id)
+
+            module = self._run_with_progress(run, f"Downloading module {module_id}...")
+
+            if module is None:
+                return 1
+
+            # Check if module has python_files (from Module.from_proto)
+            if not hasattr(module, "python_files") or not module.python_files:
+                self.print_error("Module contains no python files to download")
+                return 1
+
+            # Determine output path
+            if output_file:
+                output_path = Path(output_file)
+            else:
+                # Use module name or ID as default filename
+                module_name = getattr(module, "name", None) or module_id
+                if len(module.python_files) == 1:
+                    # Single file - use the filename from the module
+                    filename = list(module.python_files.keys())[0]
+                    output_path = Path(filename)
+                else:
+                    # Multiple files - create a directory
+                    output_path = Path(f"{module_name}_module")
+
+            # Handle single file vs directory
+            if len(module.python_files) == 1:
+                # Single file download
+                filename, content = next(iter(module.python_files.items()))
+
+                # If output_file is a directory, put file inside it
+                if output_path.is_dir():
+                    output_path = output_path / filename
+
+                # Check for conflicts
+                if output_path.exists():
+                    overwrite = Confirm.ask(
+                        f"File '{output_path}' already exists. Overwrite?"
+                    )
+                    if not overwrite:
+                        self.print("Download cancelled.")
+                        return 0
+
+                # Write single file
+                try:
+                    output_path.parent.mkdir(parents=True, exist_ok=True)
+                    output_path.write_text(content, encoding="utf-8")
+                    self.print_success(
+                        f"Module downloaded to: {output_path.absolute()}"
+                    )
+                except Exception as e:
+                    self.print_error(f"Failed to write file: {e}")
+                    return 1
+
+            else:
+                # Multiple files - create directory structure
+                if output_path.exists() and output_path.is_dir():
+                    overwrite = Confirm.ask(
+                        f"Directory '{output_path}' already exists. Continue?"
+                    )
+                    if not overwrite:
+                        self.print("Download cancelled.")
+                        return 0
+                elif output_path.exists():
+                    self.print_error(
+                        f"Path '{output_path}' exists and is not a directory"
+                    )
+                    return 1
+
+                # Create directory and write all files
+                try:
+                    output_path.mkdir(parents=True, exist_ok=True)
+
+                    files_written = 0
+                    for filename, content in module.python_files.items():
+                        file_path = output_path / filename
+
+                        # Create subdirectories if needed
+                        file_path.parent.mkdir(parents=True, exist_ok=True)
+
+                        # Write file
+                        file_path.write_text(content, encoding="utf-8")
+                        files_written += 1
+
+                    self.print_success(
+                        f"Module downloaded: {files_written} files written to {output_path.absolute()}"
+                    )
+
+                    # Show file structure
+                    tree = Tree(f"📁 {output_path.name}")
+                    for filename in sorted(module.python_files.keys()):
+                        tree.add(f"📄 {filename}")
+                    self.console.print(tree)
+
+                except Exception as e:
+                    self.print_error(f"Failed to write files: {e}")
+                    return 1
+
+            return 0
+
+        except Exception as e:
+            self.print_error(f"Failed to download module: {e}")
+            return 1

manta/cli/commands/sdk_nodes.py

@@ -0,0 +1,168 @@
+"""SDK node information and status commands."""
+
+from rich.panel import Panel
+from rich.table import Table
+
+from .base_handler import BaseSDKHandler
+from ..utils import (
+    enum_to_string,
+    timestamp_to_string,
+    extract_platform_type,
+    extract_node_resources,
+    NODE_STATUS_MAP,
+)
+
+
+class SDKNodesHandler(BaseSDKHandler):
+    """Handle node-related SDK commands."""
+
+    def add_subparsers(self, parent_parser):
+        """Add node command subparsers."""
+        subparsers = parent_parser.add_subparsers(
+            dest="node_command", help="Node commands"
+        )
+
+        # List nodes command
+        list_parser = subparsers.add_parser("list", help="List all nodes")
+        list_parser.add_argument("--cluster-id", help="Filter by cluster ID")
+
+        # Get node command
+        get_parser = subparsers.add_parser("get", help="Get detailed node information")
+        get_parser.add_argument("node_id", help="Node ID to get information for")
+
+        # Add profile override to all subcommands
+        for parser in [list_parser, get_parser]:
+            parser.add_argument("--profile", help="Use specific profile")
+
+    def handle(self, args) -> int:
+        """Handle node commands."""
+        if not args.node_command:
+            self.print_error("Node command required")
+            return 1
+
+        if args.node_command == "list":
+            return self.list_nodes(getattr(args, "cluster_id", None))
+        elif args.node_command == "get":
+            return self.get_node(args.node_id)
+        else:
+            self.print_error(f"Unknown node command: {args.node_command}")
+            return 1
+
+    def list_nodes(self, cluster_id: str = None) -> int:
+        """List all nodes, optionally filtered by cluster."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                if cluster_id:
+                    return await api.stream_and_fetch_nodes(cluster_id)
+                else:
+                    # Get all nodes across all clusters
+                    all_nodes = []
+                    clusters = await api.stream_and_fetch_clusters()
+                    for cluster in clusters:
+                        cluster_nodes = await api.stream_and_fetch_nodes(
+                            cluster["cluster_id"]
+                        )
+                        all_nodes.extend(cluster_nodes)
+                    return all_nodes
+
+            message = (
+                f"Fetching nodes{f' for cluster {cluster_id}' if cluster_id else ''}..."
+            )
+            nodes = self._run_with_progress(run, message)
+
+            if not nodes:
+                self.print("No nodes found.")
+                return 0
+
+            # Create and display nodes table
+            table = Table(
+                title=f"Nodes{f' (Cluster: {cluster_id})' if cluster_id else ''}"
+            )
+            table.add_column("Node ID", style="cyan")
+            table.add_column("Status", style="green")
+            table.add_column("Type", style="blue")
+            table.add_column("Cluster", style="magenta")
+            table.add_column("Last Seen", style="yellow")
+
+            for node in nodes:
+                # Use converter functions for consistent parsing
+                status = enum_to_string(node.get("node_status", 0), NODE_STATUS_MAP)
+
+                node_type = extract_platform_type(node.get("platform_info"))
+
+                last_seen = timestamp_to_string(
+                    node.get("updated_at") or node.get("created_at")
+                )
+
+                table.add_row(
+                    node.get("node_id", "Unknown"),
+                    status,
+                    node_type,
+                    cluster_id if cluster_id else "Unknown",
+                    last_seen,
+                )
+
+            self.console.print(table)
+
+            return 0
+
+        except Exception as e:
+            self.print_error(f"Failed to list nodes: {e}")
+            return 1
+
+    def get_node(self, node_id: str) -> int:
+        """Get detailed node information."""
+        api = self._get_user_api()
+        if not api:
+            return 1
+
+        try:
+
+            async def run():
+                # Since get_node needs cluster_id, we need to find which cluster the node belongs to
+                clusters = await api.stream_and_fetch_clusters()
+                for cluster in clusters:
+                    nodes = await api.stream_and_fetch_nodes(cluster["cluster_id"])
+                    for node in nodes:
+                        if node.get("node_id") == node_id:
+                            # Found the node, now get its detailed info
+                            return await api.get_node(cluster["cluster_id"], node_id)
+                raise ValueError(f"Node {node_id} not found in any cluster")
+
+            node = self._run_with_progress(run, f"Fetching node {node_id}...")
+
+            # Extract and format fields using converters
+            status = enum_to_string(node.get("node_status", 0), NODE_STATUS_MAP)
+
+            node_type = extract_platform_type(node.get("platform_info"))
+
+            last_seen = timestamp_to_string(
+                node.get("updated_at") or node.get("created_at")
+            )
+
+            # Extract resource information
+            resources = extract_node_resources(node.get("metrics_snapshot"))
+
+            # Display node details
+            panel = Panel.fit(
+                f"[cyan]Node ID:[/cyan] {node.get('node_id', 'Unknown')}\n"
+                f"[cyan]Status:[/cyan] {status}\n"
+                f"[cyan]Type:[/cyan] {node_type}\n"
+                f"[cyan]Cluster:[/cyan] {node.get('cluster_id', 'Unknown')}\n"
+                f"[cyan]Resources:[/cyan] CPU: {resources['cpu_count']}, "
+                f"RAM: {resources['memory_gb']}GB\n"
+                f"[cyan]Last Seen:[/cyan] {last_seen}",
+                title=f"Node: {node_id}",
+            )
+            self.console.print(panel)
+
+            return 0
+
+        except Exception as e:
+            self.print_error(f"Failed to get node details: {e}")
+            return 1