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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingera-cli
-Version: 0.1.13
+Version: 0.1.14
 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

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

@@ -2,7 +2,7 @@
 Pingera CLI - A beautiful CLI tool for Pingera Platform
 """
 
-__version__ = "0.1.13"
+__version__ = "0.1.14"
 __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.13 → pingera_cli-0.1.14}/pingera_cli/commands/on_demand_checks.py

@@ -19,8 +19,9 @@ class OnDemandChecksCommand(BaseCommand):
     Commands for managing on-demand monitoring checks
     """
     
-    def __init__(self, output_format: Optional[str] = None):
+    def __init__(self, output_format: Optional[str] = None, verbose: bool = False):
         super().__init__(output_format)
+        self.verbose = verbose
     
     def _parse_check_file(self, file_path: str) -> dict:
         """Parse check configuration from JSON or YAML file (local or URL)"""
@@ -446,15 +447,17 @@ class OnDemandChecksCommand(BaseCommand):
                 }
                 self.output_data(job_data)
             else:
-                # Rich formatted detailed view
-                self._display_detailed_job_status(job_status, job_id)
+                # Rich formatted detailed view - fetch and display with results
+                self._fetch_and_display_job_result(job_id, job_status, verbose=self.verbose)
             
         except Exception as e:
             self.display_error(f"Failed to get job status: {str(e)}")
             raise typer.Exit(1)
 
-    def _fetch_and_display_job_result(self, job_id: str, job_status):
+    def _fetch_and_display_job_result(self, job_id: str, job_status, verbose: bool = False):
         """Fetch detailed results from the new results endpoint and display them"""
+        import time
+        
         try:
             # Extract result_id(s) from job response
             result_ids = []
@@ -463,14 +466,56 @@ class OnDemandChecksCommand(BaseCommand):
             if hasattr(job_status, 'result') and job_status.result:
                 result = job_status.result
                 
+                # Debug: Print the raw result to see what we're getting (only in verbose mode)
+                if verbose and self.output_format not in ['json', 'yaml']:
+                    import json
+                    self.console.print(f"[dim]DEBUG: Raw result from job status:[/dim]")
+                    self.console.print(f"[dim]{json.dumps(result, indent=2, default=str)}[/dim]")
+                
                 # Check if this is a multi-region result
                 if isinstance(result, dict):
                     if 'regional_summary' in result and result['regional_summary']:
                         # Multi-region execution
                         is_multi_region = True
-                        for regional_result in result['regional_summary']:
+                        regional_summary = result['regional_summary']
+                        
+                        # Debug: Show what we found (only in verbose mode)
+                        if verbose and self.output_format not in ['json', 'yaml']:
+                            self.console.print(f"[dim]DEBUG: Found {len(regional_summary)} regions in regional_summary[/dim]")
+                        
+                        for regional_result in regional_summary:
                             if 'result_id' in regional_result:
                                 result_ids.append(regional_result['result_id'])
+                        
+                        # Check if we might be missing results (race condition detection)
+                        total_regions = result.get('total_regions', len(regional_summary))
+                        completed_regions = result.get('completed_regions', len(regional_summary))
+                        
+                        if verbose and self.output_format not in ['json', 'yaml']:
+                            self.console.print(f"[dim]DEBUG: total_regions={total_regions}, completed_regions={completed_regions}, found result_ids={len(result_ids)}[/dim]")
+                        
+                        # If we're missing results, wait a bit and refetch
+                        if len(result_ids) < total_regions:
+                            if self.output_format not in ['json', 'yaml']:
+                                self.console.print(f"[yellow]⚠ Race condition detected: {len(result_ids)}/{total_regions} results ready. Waiting 2s and retrying...[/yellow]")
+                            time.sleep(2)
+                            
+                            # Refetch job status
+                            checks_api = self.get_client()
+                            job_status = checks_api.v1_checks_jobs_job_id_get(job_id=job_id)
+                            
+                            # Re-extract result_ids
+                            result_ids = []
+                            if hasattr(job_status, 'result') and job_status.result:
+                                result = job_status.result
+                                if isinstance(result, dict) and 'regional_summary' in result:
+                                    for regional_result in result['regional_summary']:
+                                        if 'result_id' in regional_result:
+                                            result_ids.append(regional_result['result_id'])
+                                    
+                                    if verbose and self.output_format not in ['json', 'yaml']:
+                                        self.console.print(f"[dim]DEBUG: After retry, found {len(result_ids)} result_ids[/dim]")
+                    
                     elif 'result_id' in result:
                         # Single-region execution
                         result_ids.append(result['result_id'])
@@ -487,14 +532,14 @@ class OnDemandChecksCommand(BaseCommand):
                 raise typer.Exit(1)
             
             from pingera import ApiClient, Configuration
-            from pingera.api import ChecksApi
+            from pingera.api import ChecksUnifiedResultsApi
             from ..utils.config import get_config
             
             configuration = Configuration()
             configuration.host = get_config().get('base_url', 'https://api.pingera.ru')
             configuration.api_key['apiKeyAuth'] = api_key
             api_client = ApiClient(configuration)
-            checks_api = ChecksApi(api_client)
+            checks_api = ChecksUnifiedResultsApi(api_client)
             
             # Fetch detailed results for each result_id
             if is_multi_region:
@@ -547,13 +592,15 @@ class OnDemandChecksCommand(BaseCommand):
         self.console.print(f"\n[bold cyan]Multi-Region Execution Result[/bold cyan]")
         self.console.print(f"• Job ID: [white]{job_id}[/white]")
         self.console.print(f"• Status: [{status_color}]{status_emoji} {job_status.status}[/{status_color}]")
-        self.console.print(f"• Regions: [white]{len(result_ids)}[/white]")
         
         # Extract and display aggregated statistics
         if hasattr(job_status, 'result') and isinstance(job_status.result, dict):
             result = job_status.result
             regional_summary = result.get('regional_summary', [])
             
+            # Display region count from actual regional_summary
+            self.console.print(f"• Regions: [white]{len(regional_summary)}[/white]")
+            
             if regional_summary:
                 # Calculate aggregated statistics
                 response_times = []
@@ -616,19 +663,63 @@ class OnDemandChecksCommand(BaseCommand):
     
     def _display_detailed_result_with_job_info(self, job_status, job_id: str, detailed_result):
         """Display detailed result information combined with job info"""
-        # Use the existing detailed result display logic from checks.py
-        # For now, use the job status display and note about detailed results
-        self._display_detailed_job_status(job_status, job_id)
+        from rich.panel import Panel
+        from ..formatters.registry import FormatterRegistry
+        
+        # Determine status color and emoji
+        status_emoji = "✅" if hasattr(detailed_result, 'status') and detailed_result.status == 'ok' else "❌"
+        status_color = "green" if hasattr(detailed_result, 'status') and detailed_result.status == 'ok' else "red"
+        
+        # Basic information
+        basic_info = f"""[bold cyan]Basic Information:[/bold cyan]
+• Result ID: [white]{detailed_result.id if hasattr(detailed_result, 'id') else 'Unknown'}[/white]
+• Check ID: [white]{detailed_result.check_id if hasattr(detailed_result, 'check_id') and detailed_result.check_id else 'None'}[/white]
+• Status: [{status_color}]{status_emoji} {detailed_result.status if hasattr(detailed_result, 'status') else 'Unknown'}[/{status_color}]
+• Timestamp: [white]{detailed_result.created_at.strftime('%Y-%m-%d %H:%M:%S UTC') if hasattr(detailed_result, 'created_at') and detailed_result.created_at else 'Unknown'}[/white]"""
+        
+        if hasattr(detailed_result, 'response_time') and detailed_result.response_time:
+            basic_info += f"\n• Response Time: [yellow]{detailed_result.response_time}ms[/yellow]"
         
-        # Additional result details if available
+        # Server information
+        if hasattr(detailed_result, 'check_server') and detailed_result.check_server:
+            server = detailed_result.check_server
+            server_info = f"""• Check Server: [white]{server.id if hasattr(server, 'id') else 'Unknown'}[/white]
+• Server IP: [white]{server.ip_address if hasattr(server, 'ip_address') else 'Unknown'}[/white]
+• Server Country: [white]{server.country if hasattr(server, 'country') else 'Unknown'}[/white]
+• Server Region: [white]{server.region if hasattr(server, 'region') else 'Unknown'}[/white]"""
+            basic_info += f"\n{server_info}"
+        
+        # Error information
+        error_info = ""
+        if hasattr(detailed_result, 'error_message') and detailed_result.error_message:
+            error_info = f"""
+[bold red]Error Information:[/bold red]
+• Error: [red]{detailed_result.error_message}[/red]"""
+        
+        # Metadata analysis using formatters
+        metadata_info = ""
         if hasattr(detailed_result, 'check_metadata') and detailed_result.check_metadata:
-            from ..formatters.registry import FormatterRegistry
-            registry = FormatterRegistry(verbose=False)
-            metadata_formatted = registry.format_metadata(detailed_result.check_metadata)
+            metadata = detailed_result.check_metadata
             
-            if metadata_formatted.strip():
-                self.console.print(f"\n[bold cyan]Detailed Result Metadata:[/bold cyan]")
-                self.console.print(metadata_formatted)
+            if isinstance(metadata, dict):
+                registry = FormatterRegistry(verbose=self.verbose)
+                metadata_info = registry.format_metadata(metadata)
+        
+        # Combine all sections
+        full_info = basic_info
+        if error_info:
+            full_info += error_info
+        if metadata_info:
+            full_info += metadata_info
+        
+        panel = Panel(
+            full_info,
+            title=f"🔍 Result Details: {detailed_result.id if hasattr(detailed_result, 'id') else 'Unknown'}",
+            border_style="blue",
+            padding=(1, 2),
+        )
+        
+        self.console.print(panel)
     
     def _display_detailed_job_status(self, job_status, job_id: str):
         """Display detailed job status information in a rich format"""
@@ -806,7 +897,7 @@ class OnDemandChecksCommand(BaseCommand):
                                 time.sleep(0.5)  # Brief pause to show completion
                             
                             # Fetch and display the actual result
-                            self._fetch_and_display_job_result(job_id, job_status)
+                            self._fetch_and_display_job_result(job_id, job_status, verbose=self.verbose)
                             return
                         
                         elif job_status.status == 'running':
@@ -858,6 +949,12 @@ def get_output_format():
     return get_config().get('output_format', 'table')
 
 
+def get_verbose_mode():
+    """Get verbose mode from config"""
+    from ..utils.config import get_verbose_mode as _get_verbose_mode
+    return _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)"),
@@ -885,7 +982,7 @@ def run_custom_check(
     - tcp: --host required, --port optional  
     - ssl: --url or --host required
     - synthetic/multistep: --pw-script-file or --parameters with pw_script required"""
-    on_demand_cmd = OnDemandChecksCommand(get_output_format())
+    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)
 
 
@@ -895,7 +992,7 @@ def run_existing_check(
     no_wait: bool = typer.Option(False, "--no-wait", help="Don't wait for job completion, just queue the check and return job ID"),
 ):
     """Execute existing check on demand. By default, waits for job completion and shows result immediately (max 5 minutes). Use --no-wait to just queue the check."""
-    on_demand_cmd = OnDemandChecksCommand(get_output_format())
+    on_demand_cmd = OnDemandChecksCommand(get_output_format(), verbose=get_verbose_mode())
     on_demand_cmd.execute_existing_check(check_id, not no_wait)
 
 
@@ -905,7 +1002,7 @@ def list_jobs(
     page_size: int = typer.Option(20, "--page-size", "-s", help="Items per page"),
 ):
     """List check jobs"""
-    on_demand_cmd = OnDemandChecksCommand(get_output_format())
+    on_demand_cmd = OnDemandChecksCommand(get_output_format(), verbose=get_verbose_mode())
     on_demand_cmd.list_jobs(page, page_size)
 
 
@@ -914,5 +1011,5 @@ def get_job_status(
     job_id: str = typer.Argument(..., help="Job ID to get status for"),
 ):
     """Get job status and results. For multi-region executions, shows aggregated statistics and regional summary."""
-    on_demand_cmd = OnDemandChecksCommand(get_output_format())
+    on_demand_cmd = OnDemandChecksCommand(get_output_format(), verbose=get_verbose_mode())
     on_demand_cmd.get_job_status(job_id)

{pingera_cli-0.1.13 → pingera_cli-0.1.14}/pingera_cli/main.py

@@ -196,9 +196,10 @@ def main(
     if verbose:
         console.print("[dim]Verbose mode enabled[/dim]")
     
-    # Store current output format in config temporarily for subcommands
-    from .utils.config import set_output_format as save_output_format
+    # Store current output format and verbose mode in config temporarily for subcommands
+    from .utils.config import set_output_format as save_output_format, set_verbose_mode
     save_output_format(output)
+    set_verbose_mode(verbose)
 
 
 def cli_entry_point():

{pingera_cli-0.1.13 → pingera_cli-0.1.14}/pingera_cli/utils/config.py

@@ -158,6 +158,32 @@ def get_output_format() -> str:
     return config.get('output_format', 'table')
 
 
+def set_verbose_mode(verbose: bool) -> bool:
+    """
+    Set verbose mode in configuration file
+
+    Args:
+        verbose: Verbose mode flag
+
+    Returns:
+        bool: True if saved successfully, False otherwise
+    """
+    config = get_config()
+    config['verbose'] = verbose
+    return save_config(config)
+
+
+def get_verbose_mode() -> bool:
+    """
+    Get verbose mode from configuration
+
+    Returns:
+        bool: Verbose mode flag (default: False)
+    """
+    config = get_config()
+    return config.get('verbose', False)
+
+
 def validate_config() -> Dict[str, bool]:
     """
     Validate current configuration

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingera-cli
-Version: 0.1.13
+Version: 0.1.14
 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

{pingera_cli-0.1.13 → pingera_cli-0.1.14}/pingera_cli.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@
 LICENSE
 README.md
 assert
+pwscript.js
 pyproject.toml
 replit.md
 run_tests.py

pingera_cli-0.1.14/pwscript.js

@@ -0,0 +1,14 @@
+const { test, expect } = require('@playwright/test');
+
+test('Basic Screenshot', async ({ page }) => {
+  // Navigate to the page
+  await page.goto('https://playwright.dev/');
+
+  // Wait for the page to be in a stable state (e.g., network idle)
+  await page.waitForLoadState('load');
+
+  // Take a full-page screenshot
+  await page.screenshot({ path: 'screenshot.png', fullPage: true });
+
+  console.log('Successfully took a full-page screenshot.');
+});