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

manta/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI functionality for manta-sdk."""

manta/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands for manta-sdk."""

manta/cli/commands/base_handler.py

@@ -0,0 +1,229 @@
+"""Base command handler interface for modular SDK commands."""
+
+import asyncio
+import traceback
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..config_manager import SDKConfigManager
+
+
+class BaseSDKHandler(ABC):
+    """Base class for SDK command handlers."""
+
+    def __init__(self, console: Console, config_manager: SDKConfigManager):
+        self.console = console
+        self.config_manager = config_manager
+        self.debug = False  # Can be set to True for detailed error output
+
+    def print(self, *args, **kwargs):
+        """Print with console (always available in SDK context)."""
+        self.console.print(*args, **kwargs)
+
+    def print_error(self, message: str):
+        """Print error message."""
+        self.console.print(f"[red]Error:[/red] {message}")
+
+    def print_success(self, message: str):
+        """Print success message."""
+        self.console.print(f"[green]Success:[/green] {message}")
+
+    def print_warning(self, message: str):
+        """Print warning message."""
+        self.console.print(f"[yellow]Warning:[/yellow] {message}")
+
+    def _run_with_progress(self, async_func, message: str):
+        """Run an async function with progress indication and proper error handling."""
+        try:
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=self.console,
+                transient=True,  # Remove progress bar after completion
+            ) as progress:
+                task = progress.add_task(message, total=None)
+
+                # Create event loop and run the async function
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    result = loop.run_until_complete(async_func())
+                    progress.update(task, completed=True)
+                    return result
+                except KeyboardInterrupt:
+                    progress.stop()
+                    self.print_warning("Operation cancelled by user")
+                    raise
+                except Exception as e:
+                    progress.stop()
+                    # Extract meaningful error message
+                    error_msg = self._extract_error_message(e)
+                    self.print_error(error_msg)
+
+                    if self.debug:
+                        self.console.print(f"[dim]{traceback.format_exc()}[/dim]")
+
+                    raise
+                finally:
+                    loop.close()
+
+        except KeyboardInterrupt:
+            # Re-raise keyboard interrupt so the CLI can exit properly
+            raise
+        except Exception:
+            # Error was already printed, just return None to indicate failure
+            return None
+
+    def _extract_error_message(self, error: Exception) -> str:
+        """Extract a meaningful error message from various exception types."""
+        error_str = str(error)
+
+        # Handle gRPC errors specifically
+        if "StatusCode" in error_str:
+            # Extract the gRPC error details
+            if "UNAVAILABLE" in error_str:
+                return "Service unavailable - please check if the backend services are running"
+            elif "UNAUTHENTICATED" in error_str:
+                return "Authentication failed - please check your JWT token"
+            elif "PERMISSION_DENIED" in error_str:
+                return "Permission denied - you don't have access to this resource"
+            elif "NOT_FOUND" in error_str:
+                return "Resource not found"
+            elif "ALREADY_EXISTS" in error_str:
+                return "Resource already exists"
+            elif "DEADLINE_EXCEEDED" in error_str:
+                return "Request timed out - the operation took too long"
+            elif "CANCELLED" in error_str:
+                return "Request was cancelled"
+            elif "INTERNAL" in error_str:
+                # Try to extract the actual error message from internal errors
+                if "details =" in error_str:
+                    details_start = error_str.find("details =") + 10
+                    details_end = error_str.find('"', details_start + 1)
+                    if details_end > details_start:
+                        return f"Backend error: {error_str[details_start:details_end]}"
+                return "Internal server error"
+
+        # Handle connection errors
+        if "Failed to connect" in error_str or "Connection refused" in error_str:
+            return "Cannot connect to backend service - please check if services are running"
+
+        # Handle timeout errors
+        if "timeout" in error_str.lower():
+            return "Operation timed out - please try again"
+
+        # Default: return the original error message
+        return error_str
+
+    def _run_async(self, coro):
+        """Run async coroutine with proper error handling."""
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                return loop.run_until_complete(coro)
+            finally:
+                loop.close()
+        except KeyboardInterrupt:
+            self.print_warning("Operation cancelled by user")
+            raise
+        except Exception as e:
+            error_msg = self._extract_error_message(e)
+            self.print_error(error_msg)
+            if self.debug:
+                self.console.print(f"[dim]{traceback.format_exc()}[/dim]")
+            return None
+
+    def _get_user_api(self):
+        """Get configured AsyncUserAPI instance."""
+        try:
+            # Dynamic import of manta-sdk
+            from manta.apis import AsyncUserAPI
+
+            # Get connection parameters from config manager
+            try:
+                # Use config override if specified, otherwise use active config
+                config_name = getattr(self, "_config_override", None)
+                connection_params = self.config_manager.get_connection_params(
+                    config_name
+                )
+            except Exception as e:
+                self.print_error(f"Failed to get connection configuration: {e}")
+                return None
+
+            if not connection_params:
+                self.print_error(
+                    "No configuration found. Run 'manta sdk config init' first."
+                )
+                return None
+
+            # Create API instance with configuration
+            # Note: AsyncUserAPI constructor order is (token, host, port, cafile, certfile, keyfile)
+            # Extract certificate paths from cert_folder if use_tls is enabled
+            cafile = None
+            certfile = None
+            keyfile = None
+
+            if connection_params.get("use_tls", False) and connection_params.get(
+                "cert_folder"
+            ):
+                from pathlib import Path
+
+                cert_path = Path(connection_params["cert_folder"])
+                # Try common certificate file names
+                if (cert_path / "ca.crt").exists():
+                    cafile = str(cert_path / "ca.crt")
+                if (cert_path / "client.crt").exists():
+                    certfile = str(cert_path / "client.crt")
+                if (cert_path / "client.key").exists():
+                    keyfile = str(cert_path / "client.key")
+
+            return AsyncUserAPI(
+                token=connection_params["token"],
+                host=connection_params.get("host", "localhost"),
+                port=connection_params.get("port", 50052),
+                cafile=cafile,
+                certfile=certfile,
+                keyfile=keyfile,
+            )
+
+        except ImportError:
+            self.print_error(
+                "manta-sdk not available. Install with: pip install manta-sdk[api]"
+            )
+            return None
+        except Exception as e:
+            self.print_error(f"Failed to create API client: {e}")
+            return None
+
+    def set_profile_override(self, config: Optional[str]):
+        """Set config override for this handler."""
+        self._config_override = config
+
+    def enable_debug(self, enabled: bool = True):
+        """Enable or disable debug output."""
+        self.debug = enabled
+
+    def _format_size(self, size_bytes: float) -> str:
+        """Format byte size in human readable format."""
+        if size_bytes == 0:
+            return "0 B"
+
+        for unit in ["B", "KB", "MB", "GB", "TB"]:
+            if size_bytes < 1024.0:
+                return f"{size_bytes:.1f} {unit}"
+            size_bytes /= 1024.0
+        return f"{size_bytes:.1f} PB"
+
+    @abstractmethod
+    def add_subparsers(self, parent_parser):
+        """Add command-specific subparsers to the parent parser."""
+        pass
+
+    @abstractmethod
+    def handle(self, args) -> int:
+        """Handle command execution."""
+        pass

manta/cli/commands/doc.py

@@ -0,0 +1,192 @@
+"""Documentation commands for Manta CLI."""
+
+import webbrowser
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+class DocCommands:
+    """Handle documentation-related CLI commands."""
+
+    # Documentation URLs
+    DOCS = {
+        "main": "https://github.com/Openmesh-Network/manta",
+        "sdk": "https://github.com/Openmesh-Network/manta/blob/main/manta-sdk/README.md",
+        "node": "https://github.com/Openmesh-Network/manta/blob/main/manta-node/README.md",
+        "api": "https://github.com/Openmesh-Network/manta/blob/main/docs/api.md",
+        "examples": "https://github.com/Openmesh-Network/manta/tree/main/examples",
+        "quickstart": "https://github.com/Openmesh-Network/manta/blob/main/docs/quickstart.md",
+        "architecture": "https://github.com/Openmesh-Network/manta/blob/main/docs/architecture.md",
+        "configuration": "https://github.com/Openmesh-Network/manta/blob/main/docs/configuration.md",
+        "deployment": "https://github.com/Openmesh-Network/manta/blob/main/docs/deployment.md",
+    }
+
+    def __init__(self, console: Console):
+        self.console = console
+
+    def print(self, *args, **kwargs):
+        """Print with console."""
+        self.console.print(*args, **kwargs)
+
+    def print_error(self, message: str):
+        """Print error message."""
+        self.console.print(f"[red]Error:[/red] {message}")
+
+    def print_success(self, message: str):
+        """Print success message."""
+        self.console.print(f"[green]Success:[/green] {message}")
+
+    def print_warning(self, message: str):
+        """Print warning message."""
+        self.console.print(f"[yellow]Warning:[/yellow] {message}")
+
+    def handle(self, args) -> int:
+        """Handle documentation commands."""
+        if hasattr(args, "doc_topic") and args.doc_topic:
+            return self.show_topic(
+                args.doc_topic,
+                open_browser=args.open if hasattr(args, "open") else False,
+            )
+        else:
+            return self.show_documentation_index()
+
+    def show_documentation_index(self) -> int:
+        """Show documentation index with all available topics."""
+        self.print("📚 Manta Documentation")
+        self.print("=" * 25)
+
+        # Create table of documentation topics
+        table = Table(title="Available Documentation")
+        table.add_column("Topic", style="cyan")
+        table.add_column("Description", style="white")
+        table.add_column("Command", style="magenta")
+
+        topics = [
+            ("main", "Main documentation and README", "manta doc main"),
+            ("sdk", "SDK documentation", "manta doc sdk"),
+            ("node", "Node documentation", "manta doc node"),
+            ("api", "API reference", "manta doc api"),
+            ("examples", "Example code and tutorials", "manta doc examples"),
+            ("quickstart", "Quick start guide", "manta doc quickstart"),
+            ("architecture", "Architecture overview", "manta doc architecture"),
+            ("configuration", "Configuration guide", "manta doc configuration"),
+            ("deployment", "Deployment guide", "manta doc deployment"),
+        ]
+
+        for topic, description, command in topics:
+            table.add_row(topic, description, command)
+
+        self.console.print(table)
+
+        # Show usage help
+        panel_text = (
+            "[cyan]View documentation:[/cyan]\n"
+            "  manta doc <topic>        - Show documentation URL\n"
+            "  manta doc <topic> --open - Open in browser\n\n"
+            "[cyan]Examples:[/cyan]\n"
+            "  manta doc quickstart\n"
+            "  manta doc api --open\n\n"
+            "[cyan]Online Resources:[/cyan]\n"
+            f"  Main Docs: {self.DOCS['main']}\n"
+            f"  Examples: {self.DOCS['examples']}"
+        )
+
+        panel = Panel.fit(panel_text, title="How to Use")
+        self.console.print(panel)
+
+        return 0
+
+    def show_topic(self, topic: str, open_browser: bool = False) -> int:
+        """Show documentation for a specific topic."""
+        topic = topic.lower()
+
+        if topic not in self.DOCS:
+            self.print_error(f"Unknown documentation topic: {topic}")
+            self.print("Available topics:")
+            for t in self.DOCS.keys():
+                self.print(f"  • {t}")
+            return 1
+
+        url = self.DOCS[topic]
+
+        # Create panel with documentation info
+        panel_text = f"[cyan]Topic:[/cyan] {topic}\n[cyan]URL:[/cyan] {url}"
+
+        if topic == "main":
+            panel_text += "\n\n[yellow]Main documentation includes:[/yellow]\n"
+            panel_text += "  • Getting started guide\n"
+            panel_text += "  • Platform overview\n"
+            panel_text += "  • Installation instructions\n"
+            panel_text += "  • Basic usage examples"
+        elif topic == "sdk":
+            panel_text += "\n\n[yellow]SDK documentation includes:[/yellow]\n"
+            panel_text += "  • API client usage\n"
+            panel_text += "  • Task deployment\n"
+            panel_text += "  • Result retrieval\n"
+            panel_text += "  • Configuration management"
+        elif topic == "admin":
+            panel_text += "\n\n[yellow]Admin documentation includes:[/yellow]\n"
+            panel_text += "  • User management\n"
+            panel_text += "  • Cluster administration\n"
+            panel_text += "  • System monitoring\n"
+            panel_text += "  • Security settings"
+        elif topic == "node":
+            panel_text += "\n\n[yellow]Node documentation includes:[/yellow]\n"
+            panel_text += "  • Node installation\n"
+            panel_text += "  • Configuration options\n"
+            panel_text += "  • Resource management\n"
+            panel_text += "  • Troubleshooting"
+        elif topic == "api":
+            panel_text += "\n\n[yellow]API documentation includes:[/yellow]\n"
+            panel_text += "  • REST API endpoints\n"
+            panel_text += "  • gRPC service definitions\n"
+            panel_text += "  • Authentication methods\n"
+            panel_text += "  • Request/response schemas"
+        elif topic == "examples":
+            panel_text += "\n\n[yellow]Examples include:[/yellow]\n"
+            panel_text += "  • Federated learning examples\n"
+            panel_text += "  • Data processing pipelines\n"
+            panel_text += "  • Multi-node deployments\n"
+            panel_text += "  • Integration patterns"
+        elif topic == "quickstart":
+            panel_text += "\n\n[yellow]Quick start guide includes:[/yellow]\n"
+            panel_text += "  • 5-minute setup\n"
+            panel_text += "  • First task deployment\n"
+            panel_text += "  • Basic CLI commands\n"
+            panel_text += "  • Common workflows"
+        elif topic == "architecture":
+            panel_text += "\n\n[yellow]Architecture documentation includes:[/yellow]\n"
+            panel_text += "  • System design overview\n"
+            panel_text += "  • Component relationships\n"
+            panel_text += "  • Communication patterns\n"
+            panel_text += "  • Security architecture"
+        elif topic == "configuration":
+            panel_text += "\n\n[yellow]Configuration guide includes:[/yellow]\n"
+            panel_text += "  • Configuration file structure\n"
+            panel_text += "  • Environment variables\n"
+            panel_text += "  • Profile management\n"
+            panel_text += "  • Advanced settings"
+        elif topic == "deployment":
+            panel_text += "\n\n[yellow]Deployment guide includes:[/yellow]\n"
+            panel_text += "  • Production deployment\n"
+            panel_text += "  • Docker configuration\n"
+            panel_text += "  • Kubernetes setup\n"
+            panel_text += "  • Scaling strategies"
+
+        panel = Panel.fit(panel_text, title=f"Documentation: {topic.capitalize()}")
+        self.console.print(panel)
+
+        if open_browser:
+            self.print(f"\n🌐 Opening {url} in browser...")
+            try:
+                webbrowser.open(url)
+                self.print_success("Browser opened successfully!")
+            except Exception as e:
+                self.print_error(f"Failed to open browser: {e}")
+                self.print(f"Please visit: {url}")
+        else:
+            self.print(f"\n💡 To open in browser, use: manta doc {topic} --open")
+
+        return 0