pingera-cli 0.1.0__py3-none-any.whl

pingera_cli/__init__.py

@@ -0,0 +1,11 @@
+"""
+PingeraCLI - A beautiful CLI tool for Pingera Platform
+"""
+
+__version__ = "0.1.0"
+__author__ = "PingeraCLI Team"
+__description__ = "A beautiful Python CLI tool built with typer and rich, distributed via pip and based on Pingera SDK"
+
+from .main import app
+
+__all__ = ["app", "__version__"]

pingera_cli/__main__.py

@@ -0,0 +1,9 @@
+
+"""
+Main module entry point for python -m pingera_cli execution
+"""
+
+from .main import cli_entry_point
+
+if __name__ == "__main__":
+    cli_entry_point()

pingera_cli/commands/__init__.py

@@ -0,0 +1,11 @@
+"""
+Commands module for PingeraCLI
+"""
+
+from .auth import auth_cmd
+
+__all__ = ["auth_cmd"]
+
+from .base import BaseCommand
+
+__all__ = ["BaseCommand"]

pingera_cli/commands/auth.py

@@ -0,0 +1,214 @@
+"""
+Authentication commands for PingeraCLI
+"""
+
+import os
+from typing import Optional
+
+import typer
+from rich.panel import Panel
+from rich.prompt import Prompt
+
+from .base import BaseCommand
+from ..utils.config import get_config, save_config, get_api_key, set_api_key
+
+
+class AuthCommand(BaseCommand):
+    """
+    Authentication command handler
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.app = typer.Typer(
+            name="auth",
+            help="🔐 Manage authentication settings",
+            no_args_is_help=True,
+        )
+
+        # Register commands
+        self.app.command("login")(self.login)
+        self.app.command("status")(self.status)
+        self.app.command("logout")(self.logout)
+
+    def login(
+        self,
+        api_key: Optional[str] = typer.Option(None, "--api-key", help="Pingera API key"),
+        interactive: bool = typer.Option(False, "--interactive", "-i", help="Interactive mode"),
+    ):
+        """
+        Login to Pingera by setting API key
+        """
+        try:
+            # If no API key provided, empty, or whitespace-only, or interactive mode requested, prompt for it
+            if not api_key or not api_key.strip() or interactive:
+                try:
+                    api_key = Prompt.ask(
+                        "[bold blue]Enter your Pingera API key[/bold blue]",
+                        password=True
+                    )
+                except KeyboardInterrupt:
+                    self.console.print("\n[yellow]⚠ Operation cancelled[/yellow]")
+                    raise typer.Exit(1)
+
+            # Validate API key after potentially getting it from prompt
+            if not api_key or not api_key.strip():
+                self.console.print("[red]API key cannot be empty[/red]")
+                raise typer.Exit(1)
+
+            if len(api_key.strip()) < 10:
+                self.display_warning(
+                    "API key seems too short. Please verify it's correct.",
+                    "⚠️  Warning"
+                )
+
+            # Test the API key by making a simple request
+            self.console.print("🔍 Validating API key...")
+
+            # For now, we'll skip API validation since we need to implement the client first
+            # TODO: Add actual API key validation with Pingera SDK
+
+            # Save API key to config
+            if set_api_key(api_key.strip()):
+                self.display_success(
+                    f"✅ API key has been saved successfully!\n\n"
+                    f"You can now use all Pingera CLI commands.\n"
+                    f"Run [cyan]pngr auth status[/cyan] to verify your authentication.",
+                    "🔐 Authentication Success"
+                )
+            else:
+                self.console.print("[red]Failed to save API key to configuration file.[/red]")
+                raise typer.Exit(1)
+
+        except Exception as e:
+            self.display_error(f"Login failed: {str(e)}")
+            raise typer.Exit(1)
+
+    def status(self):
+        """
+        Check current authentication status
+        """
+        try:
+            # Check for API key in environment variable
+            env_api_key = os.getenv('PINGERA_API_KEY')
+
+            # Check for API key in config file
+            config_api_key = get_api_key()
+
+            # Determine which API key is being used
+            active_api_key = env_api_key or config_api_key
+
+            if active_api_key:
+                # Mask the API key for display
+                masked_key = active_api_key[:8] + "..." + active_api_key[-4:] if len(active_api_key) > 12 else "***"
+
+                source = "environment variable" if env_api_key else "config file"
+
+                status_content = f"""
+[green]✅ Authenticated[/green]
+
+API Key: ✓ Set ({masked_key})
+Source: {source}
+Status: [green]Active[/green]
+
+[dim]Note: Environment variable takes precedence over config file.[/dim]
+                """
+
+                # TODO: Add API key validation request here
+                # Example:
+                # try:
+                #     # Test API key with a simple request
+                #     client = PingeraClient.from_api_key(active_api_key)
+                #     # Make a test request
+                #     status_content += "\n[bold]API Status:[/bold] [green]✅ Valid[/green]"
+                # except Exception as e:
+                #     status_content += f"\n[bold]API Status:[/bold] [red]❌ Invalid ({str(e)})[/red]"
+
+            else:
+                status_content = """
+[red]❌ Not Authenticated[/red]
+
+API Key: ✗ Not set
+
+[bold]To authenticate:[/bold]
+• Run [cyan]pngr auth login --api-key YOUR_KEY[/cyan]
+• Or run [cyan]pngr auth login --interactive[/cyan]
+• Or set environment variable: [cyan]export PINGERA_API_KEY=your_key[/cyan]
+                """
+
+            panel = Panel(
+                status_content.strip(),
+                title="🔐 Authentication Status",
+                border_style="green" if active_api_key else "red",
+                padding=(1, 2),
+            )
+
+            self.console.print(panel)
+
+        except Exception as e:
+            self.display_error(f"Failed to check authentication status: {str(e)}")
+            raise typer.Exit(1)
+
+    def logout(
+        self,
+        confirm: bool = typer.Option(False, "--confirm", help="Skip confirmation prompt"),
+    ):
+        """
+        Clear stored credentials
+        """
+        try:
+            # Check if there's anything to logout from
+            config_api_key = get_api_key()
+            env_api_key = os.getenv('PINGERA_API_KEY')
+
+            if not config_api_key and not env_api_key:
+                self.display_info(
+                    "No stored credentials found. You are already logged out.",
+                    "ℹ️  Info"
+                )
+                return
+
+            # Warning about environment variable
+            if env_api_key and not confirm:
+                self.display_warning(
+                    "API key is set via environment variable (PINGERA_API_KEY).\n"
+                    "This command will only clear the config file.\n"
+                    "To fully logout, also run: [cyan]unset PINGERA_API_KEY[/cyan]",
+                    "⚠️  Environment Variable Detected"
+                )
+
+            # Confirmation prompt
+            if not confirm:
+                should_logout = self.prompt_confirmation(
+                    "Are you sure you want to clear stored credentials?",
+                    default=False
+                )
+                if not should_logout:
+                    self.console.print("[yellow]Logout cancelled[/yellow]")
+                    return
+
+            # Clear API key from config
+            config = get_config()
+            if 'api_key' in config:
+                del config['api_key']
+                if save_config(config):
+                    self.display_success(
+                        "✅ Credentials cleared from configuration file.\n\n"
+                        + ("Note: Environment variable PINGERA_API_KEY is still set." if env_api_key else "You have been logged out successfully."),
+                        "🚪 Logout Success"
+                    )
+                else:
+                    self.display_error("Failed to clear credentials from configuration file.")
+                    raise typer.Exit(1)
+            else:
+                self.display_info("No credentials found in configuration file.")
+
+        except KeyboardInterrupt:
+            self.console.print("\n[yellow]⚠ Operation cancelled[/yellow]")
+        except Exception as e:
+            self.display_error(f"Logout failed: {str(e)}")
+            raise typer.Exit(1)
+
+
+# Create the auth command instance
+auth_cmd = AuthCommand()

pingera_cli/commands/base.py

@@ -0,0 +1,251 @@
+"""
+Base command class for PingeraCLI commands
+"""
+
+import json
+from typing import Any, Dict, Optional
+from datetime import datetime
+
+try:
+    import yaml
+except ImportError:
+    yaml = None
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from ..utils.console import console, error_console
+from ..utils.config import get_config
+
+
+class BaseCommand:
+    """Base class for all CLI commands with common functionality"""
+
+    def __init__(self, output_format: Optional[str] = None):
+        self.console = console
+        self.error_console = error_console
+        self.output_format = output_format or get_config().get('output_format', 'table')
+
+    def validate_api_key(self) -> str:
+        """
+        Validate that API key is available
+
+        Returns:
+            str: The API key
+
+        Raises:
+            ValueError: If API key is not found
+        """
+        api_key = os.getenv('PINGERA_API_KEY')
+        if not api_key:
+            raise ValueError("PINGERA_API_KEY environment variable not set")
+        return api_key
+
+    def validate_pingera_sdk(self):
+        """
+        Validate that Pingera SDK is installed and importable
+
+        Raises:
+            ImportError: If Pingera SDK is not available
+        """
+        try:
+            from pingera import ApiClient, Configuration
+            return (ApiClient, Configuration)
+        except ImportError:
+            raise ImportError("Pingera SDK not installed. Install with: pip install pingera-sdk")
+
+    def display_success(self, message: str, title: str = "✅ Success"):
+        """
+        Display a success message in a panel
+
+        Args:
+            message: The success message to display
+            title: Panel title (default: "✅ Success")
+        """
+        panel = Panel(
+            message,
+            title=title,
+            border_style="green",
+            padding=(1, 2),
+        )
+        self.console.print(panel)
+
+    def display_error(self, message: str, title: str = "❌ Error"):
+        """
+        Display an error message in a panel
+
+        Args:
+            message: The error message to display
+            title: Panel title (default: "❌ Error")
+        """
+        panel = Panel(
+            message,
+            title=title,
+            border_style="red",
+            padding=(1, 2),
+        )
+        self.error_console.print(panel)
+
+    def display_warning(self, message: str, title: str = "⚠️ Warning"):
+        """Display a warning message in a panel"""
+        panel = Panel(
+            f"[yellow]{message}[/yellow]",
+            title=title,
+            border_style="yellow",
+            padding=(1, 2),
+        )
+        self.console.print(panel)
+
+    def display_info(self, message: str, title: str = "ℹ️ Info"):
+        """Display an info message in a panel"""
+        panel = Panel(
+            f"[blue]{message}[/blue]",
+            title=title,
+            border_style="blue",
+            padding=(1, 2),
+        )
+        self.console.print(panel)
+
+    def create_table(self, title: str, columns: list, rows: list) -> Table:
+        """
+        Create a rich table with the specified columns and rows
+
+        Args:
+            title: Table title
+            columns: List of column names
+            rows: List of row data (each row is a list)
+
+        Returns:
+            Table: Configured rich Table object
+        """
+        table = Table(title=title, show_header=True, header_style="bold magenta")
+
+        # Add columns
+        for column in columns:
+            table.add_column(column, style="cyan", no_wrap=False)
+
+        # Add rows
+        for row in rows:
+            table.add_row(*[str(cell) for cell in row])
+
+        return table
+
+    def display_table(self, title: str, columns: list, rows: list):
+        """
+        Display a table using rich formatting
+
+        Args:
+            title: Table title
+            columns: List of column names
+            rows: List of row data (each row is a list)
+        """
+        table = self.create_table(title, columns, rows)
+        self.console.print(table)
+
+    def prompt_confirmation(self, message: str, default: bool = False) -> bool:
+        """
+        Prompt user for confirmation
+
+        Args:
+            message: The confirmation message
+            default: Default value if user just presses enter
+
+        Returns:
+            bool: True if confirmed, False otherwise
+        """
+        default_text = "Y/n" if default else "y/N"
+        response = input(f"{message} [{default_text}]: ").lower().strip()
+
+        if not response:
+            return default
+
+        return response in ['y', 'yes', '1', 'true']
+
+    def output_data(self, data: Any, format_override: Optional[str] = None):
+        """Output data in the specified format (table, json, yaml)"""
+        output_format = format_override or self.output_format
+
+        if output_format == 'json':
+            from datetime import datetime
+
+            def json_serializer(obj):
+                """JSON serializer for datetime objects"""
+                if isinstance(obj, datetime):
+                    return obj.isoformat()
+                raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+            self.console.print(json.dumps(data, indent=2, default=json_serializer))
+        elif output_format == 'yaml':
+            if yaml is None:
+                self.console.print("[yellow]YAML support not available. Install with: pip install pyyaml[/yellow]")
+                from datetime import datetime
+
+                def json_serializer(obj):
+                    """JSON serializer for datetime objects"""
+                    if isinstance(obj, datetime):
+                        return obj.isoformat()
+                    raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+                self.console.print(json.dumps(data, indent=2, default=json_serializer))
+            else:
+                try:
+                    self.console.print(yaml.dump(data, default_flow_style=False))
+                except Exception:
+                    # Fallback to JSON if YAML fails
+                    from datetime import datetime
+
+                    def json_serializer(obj):
+                        """JSON serializer for datetime objects"""
+                        if isinstance(obj, datetime):
+                            return obj.isoformat()
+                        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+                    self.console.print(json.dumps(data, indent=2, default=json_serializer))
+        else:
+            # Default to table format - subclasses should override this
+            if isinstance(data, dict):
+                self._display_dict_as_table(data)
+            elif isinstance(data, list):
+                self._display_list_as_table(data)
+            else:
+                self.console.print(str(data))
+
+    def _display_dict_as_table(self, data: Dict[str, Any]):
+        """Display dictionary data as a table"""
+        table = Table(title="Data")
+        table.add_column("Key", style="cyan")
+        table.add_column("Value", style="white")
+
+        for key, value in data.items():
+            table.add_row(str(key), str(value))
+
+        self.console.print(table)
+
+    def _display_list_as_table(self, data: list):
+        """Display list data as a table"""
+        if not data:
+            self.console.print("No data available")
+            return
+
+        if isinstance(data[0], dict):
+            # Create table from list of dictionaries
+            table = Table(title="Data")
+            if data:
+                for key in data[0].keys():
+                    table.add_column(str(key).replace('_', ' ').title())
+
+                for item in data:
+                    row = [str(item.get(key, '')) for key in data[0].keys()]
+                    table.add_row(*row)
+
+            self.console.print(table)
+        else:
+            # Simple list
+            table = Table(title="Data")
+            table.add_column("Item", style="white")
+
+            for item in data:
+                table.add_row(str(item))
+
+            self.console.print(table)