pingera-cli 0.1.14__tar.gz → 0.1.15__tar.gz

{pingera_cli-0.1.14/pingera_cli.egg-info → pingera_cli-0.1.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingera-cli
-Version: 0.1.14
+Version: 0.1.15
 Summary: A beautiful Python CLI tool built with typer and rich, distributed via pip and based on Pingera SDK
 Home-page: https://github.com/pingera/pingera-cli
 Author: PingeraCLI Team
@@ -31,7 +31,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: typer[all]>=0.9.0
 Requires-Dist: rich>=13.0.0
-Requires-Dist: pingera-sdk>=1.0.11
+Requires-Dist: pingera-sdk>=1.0.13
 Requires-Dist: click>=8.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0; extra == "dev"

{pingera_cli-0.1.14 → pingera_cli-0.1.15}/pingera_cli/__init__.py

@@ -2,7 +2,7 @@
 Pingera CLI - A beautiful CLI tool for Pingera Platform
 """
 
-__version__ = "0.1.14"
+__version__ = "0.1.15"
 __author__ = "Pingera Team"
 __description__ = "A beautiful Python CLI tool built with typer and rich, distributed via pip and based on Pingera SDK"
 

{pingera_cli-0.1.14 → pingera_cli-0.1.15}/pingera_cli/commands/checks.py

@@ -14,6 +14,9 @@ from rich.prompt import Confirm
 from .base import BaseCommand
 from ..utils.config import get_api_key
 
+# Supported check types
+SUPPORTED_CHECK_TYPES = ["web", "api", "tcp", "ssl", "dns", "icmp", "portscan", "synthetic", "multistep"]
+
 
 class ChecksCommand(BaseCommand):
     """
@@ -412,7 +415,7 @@ class ChecksCommand(BaseCommand):
             self.display_error(str(e))
             raise typer.Exit(1)
 
-    def create_check(self, name: str, check_type: str, url: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, interval: int = 300, timeout: int = 30, parameters: Optional[str] = None, pw_script_file: Optional[str] = None, from_file: Optional[str] = None):
+    def create_check(self, name: str, check_type: str, url: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, interval: int = 300, timeout: int = 30, parameters: Optional[str] = None, pw_script_file: Optional[str] = None, from_file: Optional[str] = None, regions: Optional[str] = None):
         """Create a new monitoring check"""
         try:
             import json
@@ -525,7 +528,14 @@ class ChecksCommand(BaseCommand):
                     self.display_error(f"Failed to read Playwright script file: {str(e)}")
                     raise typer.Exit(1)
 
-            # Parse parameters JSON if provided
+            # Handle regions parameter - add to params_dict if provided and not in parameters
+            if regions is not None and parameters is None:
+                # Parse comma-separated regions into a list
+                regions_list = [r.strip() for r in regions.split(',') if r.strip()]
+                if regions_list:
+                    params_dict["regions"] = regions_list
+
+            # Parse parameters JSON if provided (this takes precedence over --regions)
             if parameters is not None:
                 try:
                     parsed_params = json.loads(parameters)
@@ -583,7 +593,7 @@ class ChecksCommand(BaseCommand):
             self.display_error(f"Failed to create check: {str(e)}")
             raise typer.Exit(1)
 
-    def update_check(self, check_id: str, name: Optional[str] = None, url: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, interval: Optional[int] = None, timeout: Optional[int] = None, active: Optional[bool] = None, parameters: Optional[str] = None, pw_script_file: Optional[str] = None):
+    def update_check(self, check_id: str, name: Optional[str] = None, url: Optional[str] = None, host: Optional[str] = None, port: Optional[int] = None, interval: Optional[int] = None, timeout: Optional[int] = None, active: Optional[bool] = None, parameters: Optional[str] = None, pw_script_file: Optional[str] = None, regions: Optional[str] = None):
         """Update an existing check"""
         try:
             import json
@@ -629,7 +639,14 @@ class ChecksCommand(BaseCommand):
                     self.display_error(f"Failed to read Playwright script file: {str(e)}")
                     raise typer.Exit(1)
 
-            # Parse parameters JSON if provided
+            # Handle regions parameter - add to params_dict if provided and not in parameters
+            if regions is not None and parameters is None:
+                # Parse comma-separated regions into a list
+                regions_list = [r.strip() for r in regions.split(',') if r.strip()]
+                if regions_list:
+                    params_dict["regions"] = regions_list
+
+            # Parse parameters JSON if provided (this takes precedence over --regions)
             if parameters is not None:
                 try:
                     parsed_params = json.loads(parameters)
@@ -749,7 +766,7 @@ class ChecksCommand(BaseCommand):
             # If result_id was specified, we're fetching a single result - display it with full formatting
             if result_id and len(response.results) == 1:
                 result = response.results[0]
-                
+
                 if self.output_format in ['json', 'yaml']:
                     result_dict = {
                         "id": str(result.id) if hasattr(result, 'id') and result.id else None,
@@ -901,10 +918,8 @@ class ChecksCommand(BaseCommand):
 
                 # Provide helpful hints based on context
                 hints = []
-                if check_id:
-                    hints.append(f"Use 'pngr checks result {check_id} <result-id>' for detailed result info")
-                else:
-                    hints.append("Use 'pngr checks results --result-id <result-id>' for detailed result info")
+                hints.append("Use 'pngr checks result <result-id>' for detailed result info")
+                if not check_id:
                     hints.append("Use 'pngr checks list' to see all available checks and their IDs")
                     hints.append("Filter results: --type <type>, --status <status>, --region <region>")
 
@@ -935,16 +950,19 @@ class ChecksCommand(BaseCommand):
             self.display_error(f"Failed to get result details: {str(e)}")
             raise typer.Exit(1)
 
-    def get_check_result_detailed(self, check_id: str, result_id: str, verbose: bool = False):
-        """Get detailed information for a specific check result using check_id and result_id"""
+    def get_check_result_detailed(self, result_id: str, verbose: bool = False):
+        """Get detailed information for a specific check result using result_id"""
         try:
-            checks_api = self.get_client()
+            unified_api = self.get_unified_results_client()
 
-            # Use the actual SDK method
-            result = checks_api.v1_checks_check_id_results_check_result_id_get(
-                check_id=check_id,
-                check_result_id=result_id
-            )
+            # Use the unified results API with result_id filter
+            response = unified_api.v1_checks_all_results_get(result_id=result_id)
+
+            if not hasattr(response, 'results') or not response.results or len(response.results) == 0:
+                self.display_error(f"Result {result_id} not found")
+                raise typer.Exit(1)
+
+            result = response.results[0]
 
             if self.output_format in ['json', 'yaml']:
                 # Full result data for JSON/YAML
@@ -979,7 +997,7 @@ class ChecksCommand(BaseCommand):
                 response_time_display = f"{result.response_time}ms"
         else:
             response_time_display = 'N/A'
-        
+
         basic_info = f"""[bold cyan]Basic Information:[/bold cyan]
 • Result ID: [white]{result.id}[/white]
 • Check ID: [white]{result.check_id}[/white]
@@ -1058,6 +1076,7 @@ class ChecksCommand(BaseCommand):
                     region_dict = {
                         "id": str(region.id) if hasattr(region, 'id') and region.id else None,
                         "display_name": region.display_name if hasattr(region, 'display_name') and region.display_name else None,
+                        "aliases": region.aliases if hasattr(region, 'aliases') and region.aliases else None,
                         "available_check_types": region.available_check_types if hasattr(region, 'available_check_types') and region.available_check_types else None
                     }
                     regions_data.append(region_dict)
@@ -1073,6 +1092,7 @@ class ChecksCommand(BaseCommand):
                 table = Table(title=table_title)
                 table.add_column("Region ID", style="cyan", min_width=15)
                 table.add_column("Display Name", style="green", min_width=25)
+                table.add_column("Aliases", style="yellow", min_width=20)
                 table.add_column("Available Check Types", style="white")
 
                 for region in response.regions:
@@ -1080,6 +1100,14 @@ class ChecksCommand(BaseCommand):
                     region_id = str(region.id) if hasattr(region, 'id') and region.id else "-"
                     display_name = region.display_name if hasattr(region, 'display_name') and region.display_name else "-"
 
+                    # Handle aliases
+                    aliases_display = "-"
+                    if hasattr(region, 'aliases') and region.aliases:
+                        if isinstance(region.aliases, list):
+                            aliases_display = ", ".join(region.aliases)
+                        else:
+                            aliases_display = str(region.aliases)
+
                     # Handle available check types
                     available_types = "-"
                     if hasattr(region, 'available_check_types') and region.available_check_types:
@@ -1091,6 +1119,7 @@ class ChecksCommand(BaseCommand):
                     table.add_row(
                         region_id,
                         display_name,
+                        aliases_display,
                         available_types
                     )
 
@@ -1169,15 +1198,15 @@ def list_checks(
 ):
     """List monitoring checks with advanced filtering options"""
     from ..utils.config import get_output_format
-    
+
     # Validate name length
     if name and len(name) > 100:
         typer.echo("Error: Name filter cannot exceed 100 characters", err=True)
         raise typer.Exit(1)
 
     # Validate check type
-    if check_type and check_type not in ["web", "api", "ssl", "tcp", "icmp", "dns", "synthetic", "multistep"]:
-        typer.echo("Error: Invalid check type. Must be one of: web, api, ssl, tcp, icmp, dns, synthetic, multistep", err=True)
+    if check_type and check_type not in SUPPORTED_CHECK_TYPES:
+        typer.echo(f"Error: Invalid check type '{check_type}'. Must be one of: {', '.join(SUPPORTED_CHECK_TYPES)}", err=True)
         raise typer.Exit(1)
 
     # Validate status values if provided
@@ -1214,7 +1243,8 @@ def create_check(
     timeout: int = typer.Option(30, "--timeout", help="Timeout in seconds"),
     parameters: Optional[str] = typer.Option(None, "--parameters", help="JSON string with check parameters (e.g., '{\"regions\": [\"US\", \"EU\"]}')"),
     pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks"),
-    from_file: Optional[str] = typer.Option(None, "--from-file", "-f", help="Path to JSON or YAML file containing check configuration")
+    from_file: Optional[str] = typer.Option(None, "--from-file", "-f", help="Path to JSON or YAML file containing check configuration"),
+    regions: Optional[str] = typer.Option(None, "--regions", help="Comma-separated list of regions (e.g., 'ru-central1,eu-west1')"),
 ):
     """Create a new monitoring check. Can be created from command line options or from a JSON/YAML file.
 
@@ -1236,8 +1266,13 @@ def create_check(
         typer.echo("Error: --name is required when not using --from-file", err=True)
         raise typer.Exit(1)
 
+    # Validate check type
+    if check_type not in SUPPORTED_CHECK_TYPES:
+        typer.echo(f"Error: Invalid check type '{check_type}'. Must be one of: {', '.join(SUPPORTED_CHECK_TYPES)}", err=True)
+        raise typer.Exit(1)
+
     checks_cmd = ChecksCommand(get_output_format())
-    checks_cmd.create_check(name, check_type, url, host, port, interval, timeout, parameters, pw_script_file, from_file)
+    checks_cmd.create_check(name, check_type, url, host, port, interval, timeout, parameters, pw_script_file, from_file, regions)
 
 
 @app.command("update")
@@ -1251,12 +1286,13 @@ def update_check(
     timeout: Optional[int] = typer.Option(None, "--timeout", help="New timeout in seconds"),
     active: bool = typer.Option(None, "--active/--inactive", help="Enable or disable the check"),
     parameters: Optional[str] = typer.Option(None, "--parameters", help="JSON string with check parameters (e.g., '{\"pw_script\": \"...\", \"regions\": [\"US\", \"EU\"]}')"),
-    pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks")
+    pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks"),
+    regions: Optional[str] = typer.Option(None, "--regions", help="Comma-separated list of regions (e.g., 'ru-central1,eu-west1')"),
 ):
     """Update an existing check. Use --parameters to provide complex parameters like Playwright scripts, regions, etc."""
     from ..utils.config import get_output_format
     checks_cmd = ChecksCommand(get_output_format())
-    checks_cmd.update_check(check_id, name, url, host, port, interval, timeout, active, parameters, pw_script_file)
+    checks_cmd.update_check(check_id, name, url, host, port, interval, timeout, active, parameters, pw_script_file, regions)
 
 
 @app.command("delete")
@@ -1284,20 +1320,25 @@ def get_results(
 ):
     """Get check results with advanced filtering. If no check_id is provided, returns unified results across all checks. Use --result-id to fetch a specific result."""
     from ..utils.config import get_output_format
+
+    # Validate check type
+    if check_type and check_type not in SUPPORTED_CHECK_TYPES:
+        typer.echo(f"Error: Invalid check type '{check_type}'. Must be one of: {', '.join(SUPPORTED_CHECK_TYPES)}", err=True)
+        raise typer.Exit(1)
+
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.get_check_results(check_id, from_date, to_date, page, page_size, status, check_type, region, result_id)
 
 
 @app.command("result")
 def get_result(
-    check_id: str = typer.Argument(..., help="Check ID"),
     result_id: str = typer.Argument(..., help="Result ID to retrieve detailed information for"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show full detailed information including network requests"),
 ):
     """Get detailed information for a specific check result"""
     from ..utils.config import get_output_format
     checks_cmd = ChecksCommand(get_output_format())
-    checks_cmd.get_check_result_detailed(check_id, result_id, verbose)
+    checks_cmd.get_check_result_detailed(result_id, verbose)
 
 
 @app.command("list-regions")
@@ -1306,6 +1347,12 @@ def list_regions(
 ):
     """List available regions for monitoring checks"""
     from ..utils.config import get_output_format
+
+    # Validate check type
+    if check_type and check_type not in SUPPORTED_CHECK_TYPES:
+        typer.echo(f"Error: Invalid check type '{check_type}'. Must be one of: {', '.join(SUPPORTED_CHECK_TYPES)}", err=True)
+        raise typer.Exit(1)
+
     checks_cmd = ChecksCommand(get_output_format())
     checks_cmd.list_regions(check_type)
 

{pingera_cli-0.1.14 → pingera_cli-0.1.15}/pingera_cli/commands/on_demand_checks.py

@@ -13,6 +13,9 @@ from rich.panel import Panel
 from .base import BaseCommand
 from ..utils.config import get_api_key
 
+# Supported check types for on-demand execution
+SUPPORTED_CHECK_TYPES = ["web", "api", "tcp", "ssl", "dns", "icmp", "portscan", "synthetic", "multistep"]
+
 
 class OnDemandChecksCommand(BaseCommand):
     """
@@ -64,7 +67,7 @@ class OnDemandChecksCommand(BaseCommand):
             self.display_error(f"Failed to initialize client: {str(e)}")
             raise typer.Exit(1)
 
-    def execute_custom_check(self, url: Optional[str] = None, check_type: str = "web", host: Optional[str] = None, port: Optional[int] = None, timeout: int = 30, name: str = "On-demand check", parameters: Optional[str] = None, pw_script_file: Optional[str] = None, from_file: Optional[str] = None, wait_for_result: bool = True):
+    def execute_custom_check(self, url: Optional[str] = None, check_type: str = "web", host: Optional[str] = None, port: Optional[int] = None, timeout: Optional[int] = None, name: str = "On-demand check", regions: Optional[str] = None, parameters: Optional[str] = None, pw_script_file: Optional[str] = None, from_file: Optional[str] = None, wait_for_result: bool = True, ports: Optional[str] = None):
         """Execute custom on-demand check"""
         try:
             import json
@@ -86,10 +89,15 @@ class OnDemandChecksCommand(BaseCommand):
                 # Command line options take precedence over file data
                 check_data = {
                     "name": filtered_file_data.get("name", name),
-                    "type": filtered_file_data.get("type", check_type),
-                    "timeout": filtered_file_data.get("timeout", timeout)
+                    "type": filtered_file_data.get("type", check_type)
                 }
                 
+                # Handle timeout - only set if explicitly provided or in file
+                if timeout is not None:
+                    check_data["timeout"] = timeout
+                elif "timeout" in filtered_file_data:
+                    check_data["timeout"] = filtered_file_data["timeout"]
+                
                 # Override with command line values if provided
                 if name != "On-demand check":  # Only override if name was explicitly provided
                     check_data["name"] = name
@@ -142,9 +150,12 @@ class OnDemandChecksCommand(BaseCommand):
                 # Build check data normally
                 check_data = {
                     "name": name,
-                    "type": check_type,
-                    "timeout": timeout
+                    "type": check_type
                 }
+                
+                # Only set timeout if explicitly provided by user
+                if timeout is not None:
+                    check_data["timeout"] = timeout
             
             # Add URL if provided (required for web, api, ssl checks)
             if url is not None:
@@ -178,7 +189,18 @@ class OnDemandChecksCommand(BaseCommand):
                     self.display_error(f"Failed to read Playwright script file: {str(e)}")
                     raise typer.Exit(1)
             
-            # Parse parameters JSON if provided
+            # Handle regions parameter - add to params_dict if provided and not in parameters
+            if regions is not None and parameters is None:
+                # Parse comma-separated regions into a list
+                regions_list = [r.strip() for r in regions.split(',') if r.strip()]
+                if regions_list:
+                    params_dict["regions"] = regions_list
+            
+            # Handle ports parameter - add to params_dict if provided and not in parameters
+            if ports is not None and parameters is None:
+                params_dict["ports"] = ports
+            
+            # Parse parameters JSON if provided (this takes precedence over --regions and --ports)
             if parameters is not None:
                 try:
                     parsed_params = json.loads(parameters)
@@ -195,11 +217,17 @@ class OnDemandChecksCommand(BaseCommand):
             
             # Validation based on check type - use the actual type from check_data
             actual_check_type = check_data.get("type", check_type)
+            
+            # Validate check type is supported
+            if actual_check_type not in SUPPORTED_CHECK_TYPES:
+                self.display_error(f"Invalid check type: {actual_check_type}. Supported types: {', '.join(SUPPORTED_CHECK_TYPES)}")
+                raise typer.Exit(1)
+            
             if actual_check_type in ['web', 'api'] and not url:
                 self.display_error(f"URL is required for {actual_check_type} checks")
                 raise typer.Exit(1)
             
-            if actual_check_type in ['tcp'] and not host:
+            if actual_check_type in ['tcp', 'portscan', 'dns', 'icmp'] and not host:
                 self.display_error(f"Host is required for {actual_check_type} checks")
                 raise typer.Exit(1)
             
@@ -702,8 +730,13 @@ class OnDemandChecksCommand(BaseCommand):
             metadata = detailed_result.check_metadata
             
             if isinstance(metadata, dict):
+                # Add result_id to metadata for formatters to use in truncation notice
+                metadata_with_id = metadata.copy()
+                if hasattr(detailed_result, 'id'):
+                    metadata_with_id['result_id'] = detailed_result.id
+                
                 registry = FormatterRegistry(verbose=self.verbose)
-                metadata_info = registry.format_metadata(metadata)
+                metadata_info = registry.format_metadata(metadata_with_id)
         
         # Combine all sections
         full_info = basic_info
@@ -958,11 +991,13 @@ def get_verbose_mode():
 @run_app.command("custom")
 def run_custom_check(
     url: Optional[str] = typer.Option(None, "--url", "-u", help="URL to monitor (required for web, api, ssl checks)"),
-    check_type: str = typer.Option("web", "--type", "-t", help="Check type (web, api, tcp, ssl, synthetic, multistep)"),
-    host: Optional[str] = typer.Option(None, "--host", help="Hostname/IP for TCP/SSL checks (max 255 characters)"),
-    port: Optional[int] = typer.Option(None, "--port", help="Port number for TCP checks (1-65535)"),
-    timeout: int = typer.Option(30, "--timeout", help="Timeout in seconds"),
+    check_type: str = typer.Option("web", "--type", "-t", help=f"Check type: {', '.join(SUPPORTED_CHECK_TYPES)}"),
+    host: Optional[str] = typer.Option(None, "--host", help="Hostname/IP for TCP/SSL/portscan/DNS/ICMP checks (max 255 characters)"),
+    port: Optional[int] = typer.Option(None, "--port", "-p", help="Port number for TCP/SSL checks (1-65535)"),
+    ports: Optional[str] = typer.Option(None, "--ports", help="Ports to scan for portscan checks (e.g., '80,443' or '1-1024'). Overridden by --parameters if both are specified."),
+    timeout: Optional[int] = typer.Option(None, "--timeout", help="Timeout in seconds (optional - backend will use defaults if not specified)"),
     name: str = typer.Option("On-demand check", "--name", "-n", help="Check name"),
+    regions: Optional[str] = typer.Option(None, "--regions", "-r", help="Comma-separated list of regions (e.g., 'ru-central1,eu-west1'). Overridden by --parameters if both are specified."),
     parameters: Optional[str] = typer.Option(None, "--parameters", help="JSON string with check parameters (e.g., '{\"regions\": [\"US\", \"EU\"]}')"),
     pw_script_file: Optional[str] = typer.Option(None, "--pw-script-file", help="Path to file containing Playwright script for synthetic/multistep checks"),
     from_file: Optional[str] = typer.Option(None, "--from-file", "-f", help="Path to JSON or YAML file containing check configuration"),
@@ -980,10 +1015,13 @@ def run_custom_check(
     Parameters vary by check type:
     - web/api: --url required
     - tcp: --host required, --port optional  
-    - ssl: --url or --host required
-    - synthetic/multistep: --pw-script-file or --parameters with pw_script required"""
+    - ssl: --url or --host required, --port optional
+    - portscan: --host required, --ports optional
+    - synthetic/multistep: --pw-script-file or --parameters with pw_script required
+    
+    Timeout is optional - if not specified, backend will use appropriate defaults for each check type."""
     on_demand_cmd = OnDemandChecksCommand(get_output_format(), verbose=get_verbose_mode())
-    on_demand_cmd.execute_custom_check(url, check_type, host, port, timeout, name, parameters, pw_script_file, from_file, not no_wait)
+    on_demand_cmd.execute_custom_check(url, check_type, host, port, timeout, name, regions, parameters, pw_script_file, from_file, not no_wait, ports)
 
 
 @run_app.command("existing")

{pingera_cli-0.1.14 → pingera_cli-0.1.15}/pingera_cli/formatters/__init__.py

@@ -9,7 +9,8 @@ from .multistep_formatter import MultistepFormatter
 from .web_formatter import WebFormatter
 from .icmp_formatter import ICMPFormatter
 from .dns_formatter import DNSFormatter
+from .portscan_formatter import PortscanFormatter
 from .generic_formatter import GenericFormatter
 from .registry import FormatterRegistry
 
-__all__ = ['SSLFormatter', 'SyntheticFormatter', 'MultistepFormatter', 'WebFormatter', 'ICMPFormatter', 'DNSFormatter', 'GenericFormatter', 'FormatterRegistry']
+__all__ = ['SSLFormatter', 'SyntheticFormatter', 'MultistepFormatter', 'WebFormatter', 'ICMPFormatter', 'DNSFormatter', 'PortscanFormatter', 'GenericFormatter', 'FormatterRegistry']

{pingera_cli-0.1.14 → pingera_cli-0.1.15}/pingera_cli/formatters/base_formatter.py

@@ -43,3 +43,10 @@ class BaseFormatter(ABC):
     def _format_duration(self, duration_ms: float) -> str:
         """Format duration in milliseconds"""
         return f"{duration_ms:.0f}ms" if duration_ms > 0 else "0ms"
+    
+    def _get_truncation_notice(self, result_id: str = None) -> str:
+        """Get truncation notice with result_id if available"""
+        if result_id:
+            return f"\n[dim]💡 Some details truncated. Use --verbose flag or view full results at:[/dim]\n[dim]   https://app.pingera.ru/checks/jobs/{result_id}[/dim]\n[dim]   pngr checks result {result_id} --verbose[/dim]"
+        else:
+            return "\n[dim]💡 Some details truncated. Use --verbose flag for full details.[/dim]"

{pingera_cli-0.1.14 → pingera_cli-0.1.15}/pingera_cli/formatters/multistep_formatter.py

@@ -1,4 +1,3 @@
-
 """
 Multistep check result formatter
 """
@@ -9,103 +8,103 @@ from .base_formatter import BaseFormatter
 
 class MultistepFormatter(BaseFormatter):
     """Formatter for multistep check results"""
-    
+
     def can_format(self, metadata: Dict[str, Any]) -> bool:
         """Check if this is multistep metadata"""
         return 'test_results' in metadata and 'test_summary' in metadata
-    
+
     def format(self, metadata: Dict[str, Any]) -> str:
         """Format multistep check metadata"""
         info = "\n[bold cyan]Multistep Check Results:[/bold cyan]"
-        
+
         # Execution time
         if 'execution_time' in metadata:
             info += f"\n• Total Execution Time: [yellow]{metadata['execution_time']}ms[/yellow]"
-        
+
         # Test Summary
         if 'test_summary' in metadata:
             info += self._format_test_summary(metadata['test_summary'])
-        
+
         # Test Results
         if 'test_results' in metadata and metadata['test_results']:
             info += self._format_test_results(metadata['test_results'])
-        
+
         # Location info
         if 'region' in metadata:
             info += f"\n• Region: [white]{metadata['region']}[/white]"
         if 'provider' in metadata:
             info += f"\n• Provider: [white]{metadata['provider']}[/white]"
-        
+
         # Logs
         if 'logs' in metadata and metadata['logs']:
             info += self._format_logs(metadata['logs'])
-        
+
         return info
-    
+
     def _format_test_summary(self, summary: Dict[str, Any]) -> str:
         """Format test summary"""
         total = summary.get('total', 0)
         passed = summary.get('passed', 0)
         failed = summary.get('failed', 0)
         duration = summary.get('duration', 0)
-        
+
         info = f"\n\n[bold cyan]Test Summary:[/bold cyan]"
         info += f"\n• Tests: [green]{passed} passed[/green], [red]{failed} failed[/red], [white]{total} total[/white]"
         info += f"\n• Duration: [yellow]{duration}ms[/yellow]"
-        
+
         return info
-    
+
     def _format_test_results(self, test_results: List[Dict[str, Any]]) -> str:
         """Format test results"""
         info = "\n\n[bold cyan]Test Results:[/bold cyan]"
-        
+
         for i, test in enumerate(test_results, 1):
             status_color = "green" if test.get('status') == 'passed' else "red"
             status_icon = "✅" if test.get('status') == 'passed' else "❌"
             test_name = test.get('name', f'Test {i}')
             duration = test.get('duration', 0)
-            
+
             info += f"\n• {test_name}: [{status_color}]{status_icon} {test.get('status', 'unknown')}[/{status_color}]"
             info += f" ([yellow]{duration}ms[/yellow])"
-            
+
             # Soft assertion errors
             if test.get('softAssertionErrors', 0) > 0:
                 info += f" [yellow]⚠️ {test['softAssertionErrors']} soft assertion errors[/yellow]"
-            
+
             # Error details
             if test.get('error'):
                 error_text = self._truncate_text(test['error'], 80) if not self.verbose else test['error']
                 info += f"\n  [red]Error: {error_text}[/red]"
-            
+
             # Steps
             if 'steps' in test and test['steps']:
                 info += self._format_test_steps(test['steps'])
-        
+
         return info
-    
+
     def _format_test_steps(self, steps: List[Dict[str, Any]]) -> str:
         """Format test steps"""
         info = f"\n  [bold dim]Steps:[/bold dim]"
-        
+
         for i, step in enumerate(steps, 1):
             status_color = "green" if step.get('status') == 'passed' else "red"
             status_icon = "✓" if step.get('status') == 'passed' else "✗"
             step_name = step.get('name', f'Step {i}')
             duration = step.get('duration', 0)
-            
+
             info += f"\n    {i}. {step_name}: [{status_color}]{status_icon}[/{status_color}] ([dim]{duration}ms[/dim])"
-            
+
             # Step error
             if step.get('error') and (self.verbose or step.get('status') == 'failed'):
                 error_text = self._truncate_text(step['error'], 60) if not self.verbose else step['error']
                 info += f"\n       [red]Error: {error_text}[/red]"
-        
+
         return info
-    
+
     def _format_logs(self, logs: List[Dict[str, Any]]) -> str:
         """Format execution logs"""
         info = "\n\n[bold cyan]Execution Logs:[/bold cyan]"
-        
+
         if not self.verbose:
             info += f"\n• [dim]Found {len(logs)} log entries (use --verbose to see all)[/dim]"
             # Show only first few logs in non-verbose mode
@@ -113,7 +112,7 @@ class MultistepFormatter(BaseFormatter):
                 level = log.get('level', 'log')
                 message = self._truncate_text(log.get('message', ''), 60)
                 timestamp = log.get('timestamp', '')
-                
+
                 level_color = self._get_log_level_color(level)
                 info += f"\n• [{level_color}]{level.upper()}[/{level_color}]: [dim]{message}[/dim]"
         else:
@@ -122,12 +121,12 @@ class MultistepFormatter(BaseFormatter):
                 level = log.get('level', 'log')
                 message = log.get('message', '')
                 timestamp = log.get('timestamp', '')
-                
+
                 level_color = self._get_log_level_color(level)
                 info += f"\n• [{level_color}]{level.upper()}[/{level_color}] [{timestamp}]: {message}"
-        
+
         return info
-    
+
     def _get_log_level_color(self, level: str) -> str:
         """Get color for log level"""
         colors = {
@@ -138,4 +137,4 @@ class MultistepFormatter(BaseFormatter):
             'log': 'white',
             'debug': 'dim'
         }
-        return colors.get(level.lower(), 'white')
+        return colors.get(level.lower(), 'white')