plotly-cloud 0.1.0rc1__py3-none-any.whl

plotly_cloud/cli.py

@@ -0,0 +1,286 @@
+"""Main CLI entry point for Plotly Cloud."""
+
+import asyncio
+import sys
+import textwrap
+from collections.abc import Sequence
+from typing import Union
+
+import nest_asyncio
+from rich.console import Console
+from rich.panel import Panel
+
+from plotly_cloud._commands import BaseCommand, CommandRegistry
+from plotly_cloud._definitions import CommandArgument, HelpPanelStyle
+from plotly_cloud._parser import parse_args, parse_group_and_command
+from plotly_cloud.exceptions import PlotlyCloudError
+
+console = Console()
+
+
+def create_help_panel(arguments: Sequence[Union[CommandArgument, dict]], title: str, style: HelpPanelStyle) -> None:
+    """Create a Rich panel for command arguments with proper styling and layout."""
+    formatted_lines = []
+
+    for arg in arguments:
+        # Format the argument name with padding and color
+        arg_name = arg["name"].ljust(style["argument_width"])
+        formatted_arg = f"[{style['argument_color']}]{arg_name}[/{style['argument_color']}]"
+
+        # Format description with color and wrap to terminal width
+        max_width = console.width - style["argument_width"] - 4  # Account for padding and spacing
+        wrapper = textwrap.TextWrapper(width=max_width)
+        wrapped_desc = wrapper.fill(arg["help"])
+        description = f"[{style['description_color']}]{wrapped_desc}[/{style['description_color']}]"
+
+        # Combine argument and description on same line
+        arg_line = f"{formatted_arg} {description}"
+        formatted_lines.append(arg_line)
+
+        arg_default = arg.get("default")
+
+        # Add default value on separate line if present
+        if arg_default is not None:
+            default_text = (
+                f"[{style['description_color']}]{''.ljust(style['argument_width'])} "
+                f"(default: {arg_default})[/{style['description_color']}]"
+            )
+            formatted_lines.append(default_text)
+
+    content = "\n".join(formatted_lines)
+    panel = Panel(
+        content,
+        title=title,
+        title_align="left",
+        border_style=style["border_style"],
+        padding=(0, 1),
+    )
+    console.print(panel)
+
+
+def create_error_panel(content, title="✗ Error"):
+    console.print()
+    panel = Panel(
+        content,
+        title=title,
+        title_align="left",
+        border_style="red",
+        padding=(0, 1),
+    )
+    console.print(panel)
+
+
+def print_main_help(show_banner=True) -> None:
+    """Print main help with ASCII art and command groups."""
+    # Add ASCII art for main command
+    ascii_art = """[blue]
+   ██████╗ ██╗      ██████╗ ████████╗██╗  ██╗   ██╗
+   ██╔══██╗██║     ██╔═══██╗╚══██╔══╝██║  ╚██╗ ██╔╝
+   ██████╔╝██║     ██║   ██║   ██║   ██║   ╚████╔╝
+   ██╔═══╝ ██║     ██║   ██║   ██║   ██║    ╚██╔╝
+   ██║     ███████╗╚██████╔╝   ██║   ███████╗██║
+   ╚═╝     ╚══════╝ ╚═════╝    ╚═╝   ╚══════╝╚═╝[/blue]
+[cyan]         📊 Interactive Data Visualization Platform 📈[/cyan]
+
+[dim]Publish and manage your Dash applications with ease[/dim]
+
+"""
+    if show_banner:
+        console.print(ascii_art)
+
+    # Show command groups
+    for group_name, group in CommandRegistry.commands.items():
+        commands = []
+        for cmd_name, cmd_class in group["commands"].items():
+            commands.append({"name": f"{group_name} {cmd_name}", "help": cmd_class.short_description})
+
+        commands_style: HelpPanelStyle = {
+            "border_style": "dim blue",
+            "argument_color": "yellow",
+            "description_color": "dim",
+            "argument_width": 32,
+        }
+
+        panel_title = f"{group_name.upper()} COMMANDS"
+        create_help_panel(commands, panel_title, commands_style)
+
+    # Show global options
+    global_options = [
+        {
+            "name": "--verbose, -v",
+            "help": "Enable verbose output with detailed error information",
+        },
+        {"name": "--help, -h", "help": "Show this help message and exit"},
+    ]
+
+    options_style: HelpPanelStyle = {
+        "border_style": "dim white",
+        "argument_color": "yellow",
+        "description_color": "dim",
+        "argument_width": 32,
+    }
+
+    create_help_panel(global_options, "GLOBAL OPTIONS", options_style)
+
+
+def print_group_help(group_name: str) -> None:
+    """Print help for a specific group."""
+    group = CommandRegistry.commands.get(group_name)
+    if not group:
+        create_error_panel(
+            f"Unknown command group: [yellow]'{group_name}[/yellow]'\n\n"
+            f"Available groups: [cyan]{', '.join(CommandRegistry.commands.keys())}[/cyan]"
+        )
+        sys.exit(1)
+
+    # Type guard to ensure group is not None
+    assert group is not None
+
+    # Create commands list for the panel
+    commands = []
+    for cmd_name, cmd_class in group["commands"].items():
+        commands.append({"name": f"{group_name} {cmd_name}", "help": cmd_class.short_description})
+
+    # Define style for group help
+    group_style: HelpPanelStyle = {
+        "border_style": "dim blue",
+        "argument_color": "yellow",
+        "description_color": "dim",
+        "argument_width": 32,
+    }
+
+    panel_title = f"{group_name.upper()} COMMANDS"
+    create_help_panel(commands, panel_title, group_style)
+
+    console.print(f"\nUse 'plotly {group_name} <command> --help' for more information about a command.")
+
+
+def print_command_help(command_class: BaseCommand, group: str, command: str) -> None:
+    """Print help for a specific command."""
+    console.print(f"\n[bold blue]plotly {group} {command}[/bold blue]\n")
+
+    if command_class.description:
+        console.print(f"{command_class.description}\n")
+
+    # Use the PlotlyHelpFormatter logic for command arguments
+    if command_class.arguments:
+        # Define styles
+        args_style: HelpPanelStyle = {
+            "border_style": "dim blue",
+            "argument_color": "yellow",
+            "description_color": "dim",
+            "argument_width": 32,
+        }
+
+        options_style: HelpPanelStyle = {
+            "border_style": "dim white",
+            "argument_color": "yellow",
+            "description_color": "dim",
+            "argument_width": 32,
+        }
+
+        # Separate positional and optional arguments
+        positional_args = [arg for arg in command_class.arguments if not arg["name"].startswith("-")]
+        optional_args = [arg for arg in command_class.arguments if arg["name"].startswith("-")]
+
+        # Create panels for arguments
+        if positional_args:
+            create_help_panel(positional_args, "ARGUMENTS", args_style)
+
+        if optional_args:
+            create_help_panel(optional_args, "OPTIONS", options_style)
+
+    # Show global options
+    global_options = [
+        {
+            "name": "--verbose, -v",
+            "help": "Enable verbose output with detailed error information",
+        },
+        {"name": "--help, -h", "help": "Show this help message and exit"},
+    ]
+
+    options_style: HelpPanelStyle = {
+        "border_style": "dim white",
+        "argument_color": "yellow",
+        "description_color": "dim",
+        "argument_width": 32,
+    }
+
+    create_help_panel(global_options, "GLOBAL OPTIONS", options_style)
+
+
+def main() -> None:
+    """Main CLI entry point."""
+    # Allow to run multiple calls to asyncio run.
+    nest_asyncio.apply()
+
+    # Parse group and command
+    group, command, args_index = parse_group_and_command()
+
+    # Handle help command
+    if group == "help" or command == "help":
+        if group == "help" and command == "help":
+            # Show main help
+            print_main_help()
+            sys.exit(0)
+        elif command == "help":
+            # Show group help
+            print_group_help(group)
+            sys.exit(0)
+
+    try:
+        # Find the command group
+        group_data = CommandRegistry.commands.get(group)
+
+        # Type guard to ensure group_data is not None
+        assert group_data is not None
+
+        # Find the command in the group
+        command_class = group_data["commands"].get(command)
+        if not command_class:
+            create_error_panel(
+                f"Unknown command: {group} {command}\n\n"
+                f"Available commands in [yellow]'{group}'[/yellow]: "
+                f"[cyan]{', '.join(group_data['commands'].keys())}[/cyan]"
+            )
+            sys.exit(1)
+
+        # Type guard to ensure command_class is not None
+        assert command_class is not None
+
+        # Parse arguments specific to this command
+        command_args = parse_args(command_class.arguments)
+
+        # Handle command help
+        if command_args.help:
+            print_command_help(command_class, group, command)
+            sys.exit(0)
+
+        # Execute the command
+        asyncio.run(command_class.execute(command_args))
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+    except PlotlyCloudError as e:
+        # Display custom exceptions in a red panel with class name as title
+        args = parse_args([], args_index)
+        if args.verbose:
+            console.print_exception()
+        else:
+            content = str(e)
+            if e.details:
+                content += f"\n\n{e.details}"
+            create_error_panel(content, f"✗ {e.__class__.__name__}")
+        sys.exit(1)
+    except Exception as e:
+        # Fallback for unexpected exceptions
+        args = parse_args([], args_index)
+        if args.verbose:
+            console.print_exception()
+        else:
+            create_error_panel(str(e), "✗ Unexpected Error")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

plotly_cloud/cloud-env.toml

@@ -0,0 +1,6 @@
+# Plotly Cloud CLI Configuration
+# This file contains the configuration for Plotly Cloud.
+# Edit this file to configure your OAuth client ID and API endpoint.
+
+api_base_url = "cloud.plotly.com"
+oauth_client_id = "client_01JBHED1ZCBXX7811MDKFJ74SG"

plotly_cloud/exceptions.py

@@ -0,0 +1,198 @@
+"""Custom exceptions for Plotly Cloud CLI."""
+
+from typing import Optional
+
+
+class PlotlyCloudError(Exception):
+    """Base exception for all Plotly Cloud CLI errors."""
+
+    def __init__(self, message: str, details: Optional[str] = None):
+        """Initialize exception with message and optional details."""
+        super().__init__(message)
+        self.message = message
+        self.details = details
+
+    def __str__(self) -> str:
+        """Return formatted error message."""
+        if self.details:
+            return f"{self.message}: {self.details}"
+        return self.message
+
+
+class AuthenticationError(PlotlyCloudError):
+    """Raised when authentication fails."""
+
+    pass
+
+
+class ConfigurationError(PlotlyCloudError):
+    """Raised when configuration is invalid or missing."""
+
+    pass
+
+
+class DeploymentError(PlotlyCloudError):
+    """Raised when deployment operations fail."""
+
+    pass
+
+
+class ApplicationError(PlotlyCloudError):
+    """Raised when application operations fail."""
+
+    pass
+
+
+# Authentication-specific exceptions
+class OAuthClientError(AuthenticationError):
+    """Raised when OAuth client operations fail."""
+
+    pass
+
+
+class TokenError(AuthenticationError):
+    """Raised when token operations fail."""
+
+    pass
+
+
+class CredentialError(AuthenticationError):
+    """Raised when credential operations fail."""
+
+    pass
+
+
+class ForbiddenError(AuthenticationError):
+    """Raised when access is forbidden (HTTP 403)."""
+
+    pass
+
+
+# Configuration-specific exceptions
+class CloudConfigError(ConfigurationError):
+    """Raised when cloud configuration operations fail."""
+
+    pass
+
+
+class EnvironmentError(ConfigurationError):
+    """Raised when environment configuration is invalid."""
+
+    pass
+
+
+# Deployment-specific exceptions
+class DependencyValidationError(DeploymentError):
+    """Raised when dependency validation fails."""
+
+    pass
+
+
+class PackagingError(DeploymentError):
+    """Raised when packaging operations fail."""
+
+    pass
+
+
+class UploadError(DeploymentError):
+    """Raised when upload operations fail."""
+
+    pass
+
+
+class AppCreationError(DeploymentError):
+    """Raised when app creation fails."""
+
+    pass
+
+
+class AppPublishError(DeploymentError):
+    """Raised when app publishing fails."""
+
+    pass
+
+
+class DeploymentClientError(DeploymentError):
+    """Raised when deployment client operations fail."""
+
+    pass
+
+
+# Application-specific exceptions
+class ModuleImportError(ApplicationError):
+    """Raised when module import fails."""
+
+    pass
+
+
+class DashAppError(ApplicationError):
+    """Raised when Dash app operations fail."""
+
+    pass
+
+
+class ServerError(ApplicationError):
+    """Raised when server operations fail."""
+
+    pass
+
+
+# Network-specific exceptions
+class APIError(PlotlyCloudError):
+    """Raised when API operations fail."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        details: Optional[str] = None,
+    ):
+        """Initialize API error with optional status code."""
+        super().__init__(message, details)
+        self.status_code = status_code
+
+    def __str__(self) -> str:
+        """Return formatted error message with status code."""
+        msg = self.message
+        if self.status_code:
+            msg = f"{msg} (HTTP {self.status_code})"
+        if self.details:
+            msg = f"{msg}: {self.details}"
+        return msg
+
+
+class NetworkError(PlotlyCloudError):
+    """Raised when network operations fail."""
+
+    pass
+
+
+class TimeoutError(PlotlyCloudError):
+    """Raised when operations timeout."""
+
+    pass
+
+
+# File system exceptions
+class FileSystemError(PlotlyCloudError):
+    """Raised when file system operations fail."""
+
+    pass
+
+
+class FileNotFoundError(FileSystemError):
+    """Raised when required files are not found."""
+
+    pass
+
+
+class FilePermissionError(FileSystemError):
+    """Raised when file permission operations fail."""
+
+    pass
+
+
+class FileSizeError(FileSystemError):
+    """Raised when file size limits are exceeded."""
+
+    pass