ecosyste-ms-cli 1.3.2__py3-none-any.whl

ecosystems_cli/commands/resolve.py

@@ -0,0 +1,160 @@
+"""Commands for the resolve API."""
+
+import time
+from typing import Optional
+
+import click
+from rich.console import Console
+
+from ecosystems_cli.commands.decorators import common_options
+from ecosystems_cli.commands.execution import update_context
+from ecosystems_cli.commands.generator import APICommandGenerator
+from ecosystems_cli.constants import DEFAULT_OUTPUT_FORMAT, DEFAULT_TIMEOUT
+from ecosystems_cli.exceptions import EcosystemsCLIError
+from ecosystems_cli.helpers.get_domain import build_base_url, get_domain_with_precedence
+from ecosystems_cli.helpers.print_error import print_error
+from ecosystems_cli.helpers.print_output import print_output
+from ecosystems_cli.openapi_client import _factory as api_factory
+
+console = Console()
+
+resolve = APICommandGenerator.create_api_group("resolve")
+
+
+# Remove auto-generated create_job command to replace with custom implementation
+if "create_job" in resolve.commands:
+    del resolve.commands["create_job"]
+
+
+@resolve.command(name="create_job", help="Submit a resolve job")
+@click.argument("package_name", required=True)
+@click.argument("registry", required=True)
+@click.option("--version", default=None, help="Resolve only with version within this range")
+@click.option("--before", default=None, help="Resolve only with dependencies before this date")
+@click.option(
+    "--polling-interval",
+    type=float,
+    default=None,
+    help="Polling interval in seconds. If set, the command will poll the job status until completion.",
+)
+@common_options
+@click.pass_context
+def create_job(
+    ctx,
+    timeout: int,
+    format: str,
+    domain: Optional[str],
+    mailto: Optional[str],
+    package_name: str,
+    registry: str,
+    version: Optional[str],
+    before: Optional[str],
+    polling_interval: Optional[float],
+):
+    """Submit a resolve job.
+
+    Args:
+        ctx: Click context
+        timeout: Request timeout
+        format: Output format
+        domain: API domain
+        mailto: Email for polite pool access
+        package_name: Name of the package
+        registry: Name of the package registry
+        version: Optional version range
+        before: Optional date to resolve dependencies before
+        polling_interval: Optional polling interval in seconds
+    """
+    update_context(ctx, timeout, format, domain, mailto)
+
+    # Get domain with proper precedence
+    api_domain = get_domain_with_precedence("resolve", ctx.obj.get("domain"))
+    base_url = build_base_url(api_domain, "resolve")
+
+    try:
+        # Create the job
+        from ecosystems_cli.commands.handlers import OperationHandlerFactory
+
+        handler = OperationHandlerFactory.get_handler("resolve")
+
+        kwargs = {
+            "package_name": package_name,
+            "registry": registry,
+        }
+        if version:
+            kwargs["version"] = version
+        if before:
+            kwargs["before"] = before
+
+        path_params, query_params = handler.build_params("createJob", (), kwargs)
+
+        result = api_factory.call(
+            "resolve",
+            "createJob",
+            path_params=path_params,
+            query_params=query_params,
+            timeout=ctx.obj.get("timeout", DEFAULT_TIMEOUT),
+            mailto=ctx.obj.get("mailto"),
+            base_url=base_url,
+        )
+
+        # If polling is enabled, poll for job completion
+        if polling_interval is not None:
+            # Try to get job ID from direct response or from location URL
+            job_id = result.get("id")
+
+            if not job_id:
+                # Try to extract job ID from location URL
+                location = result.get("location", "")
+                if location:
+                    # Extract job ID from URL like: https://resolve.ecosyste.ms/api/v1/jobs/{job_id}
+                    parts = location.rstrip("/").split("/")
+                    if len(parts) > 0:
+                        job_id = parts[-1]
+
+            if not job_id:
+                print_error("No job ID in response, cannot poll for completion", console=console)
+                print_output(result, ctx.obj.get("format", DEFAULT_OUTPUT_FORMAT), console=console)
+                return
+
+            # Only show progress messages in interactive mode (table format)
+            output_format = ctx.obj.get("format", DEFAULT_OUTPUT_FORMAT)
+            is_interactive = output_format == "table"
+
+            if is_interactive:
+                console.print(f"[yellow]Job created with ID: {job_id}[/yellow]")
+                console.print(f"[yellow]Polling every {polling_interval} seconds...[/yellow]")
+
+            while True:
+                time.sleep(polling_interval)
+
+                # Get job status
+                handler_get = OperationHandlerFactory.get_handler("resolve")
+                path_params_get, query_params_get = handler_get.build_params("getJob", (), {"job_id": job_id})
+
+                job_status = api_factory.call(
+                    "resolve",
+                    "getJob",
+                    path_params=path_params_get,
+                    query_params=query_params_get,
+                    timeout=ctx.obj.get("timeout", DEFAULT_TIMEOUT),
+                    mailto=ctx.obj.get("mailto"),
+                    base_url=base_url,
+                )
+
+                status = job_status.get("status", "unknown")
+                if is_interactive:
+                    console.print(f"[cyan]Job status: {status}[/cyan]")
+
+                # Check if job is complete
+                if status in ["completed", "complete", "success", "failed", "error"]:
+                    print_output(job_status, output_format, console=console)
+                    break
+        else:
+            # No polling, just print the result
+            print_output(result, ctx.obj.get("format", DEFAULT_OUTPUT_FORMAT), console=console)
+
+    except EcosystemsCLIError as e:
+        print_error(str(e), console=console)
+    except Exception as e:
+        print_error(f"Unexpected error: {str(e)}", console=console)

ecosystems_cli/commands/sbom.py

@@ -0,0 +1,135 @@
+"""Commands for the sbom API."""
+
+import time
+from typing import Optional
+
+import click
+from rich.console import Console
+
+from ecosystems_cli.commands.decorators import common_options
+from ecosystems_cli.commands.execution import update_context
+from ecosystems_cli.commands.generator import APICommandGenerator
+from ecosystems_cli.constants import DEFAULT_OUTPUT_FORMAT, DEFAULT_TIMEOUT
+from ecosystems_cli.exceptions import EcosystemsCLIError
+from ecosystems_cli.helpers.get_domain import build_base_url, get_domain_with_precedence
+from ecosystems_cli.helpers.print_error import print_error
+from ecosystems_cli.helpers.print_output import print_output
+from ecosystems_cli.openapi_client import _factory as api_factory
+
+console = Console()
+
+sbom = APICommandGenerator.create_api_group("sbom")
+
+
+# Remove auto-generated create_job command to replace with custom implementation
+if "create_job" in sbom.commands:
+    del sbom.commands["create_job"]
+
+
+@sbom.command(name="create_job", help="Submit a dependency parsing job")
+@click.argument("url", required=True)
+@click.option(
+    "--polling-interval",
+    type=float,
+    default=None,
+    help="Polling interval in seconds. If set, the command will poll the job status until completion.",
+)
+@common_options
+@click.pass_context
+def create_job(
+    ctx, timeout: int, format: str, domain: Optional[str], mailto: Optional[str], url: str, polling_interval: Optional[float]
+):
+    """Submit a dependency parsing job.
+
+    Args:
+        ctx: Click context
+        timeout: Request timeout
+        format: Output format
+        domain: API domain
+        mailto: Email for polite pool access
+        url: URL of file or zip/tar archive
+        polling_interval: Optional polling interval in seconds
+    """
+    update_context(ctx, timeout, format, domain, mailto)
+
+    # Get domain with proper precedence
+    api_domain = get_domain_with_precedence("sbom", ctx.obj.get("domain"))
+    base_url = build_base_url(api_domain, "sbom")
+
+    try:
+        # Create the job
+        from ecosystems_cli.commands.handlers import OperationHandlerFactory
+
+        handler = OperationHandlerFactory.get_handler("sbom")
+        path_params, query_params = handler.build_params("createJob", (), {"url": url})
+
+        result = api_factory.call(
+            "sbom",
+            "createJob",
+            path_params=path_params,
+            query_params=query_params,
+            timeout=ctx.obj.get("timeout", DEFAULT_TIMEOUT),
+            mailto=ctx.obj.get("mailto"),
+            base_url=base_url,
+        )
+
+        # If polling is enabled, poll for job completion
+        if polling_interval is not None:
+            # Try to get job ID from direct response or from location URL
+            job_id = result.get("id")
+
+            if not job_id:
+                # Try to extract job ID from location URL
+                location = result.get("location", "")
+                if location:
+                    # Extract job ID from URL like: https://sbom.ecosyste.ms/api/v1/jobs/{job_id}
+                    parts = location.rstrip("/").split("/")
+                    if len(parts) > 0:
+                        job_id = parts[-1]
+
+            if not job_id:
+                print_error("No job ID in response, cannot poll for completion", console=console)
+                print_output(result, ctx.obj.get("format", DEFAULT_OUTPUT_FORMAT), console=console)
+                return
+
+            # Only show progress messages in interactive mode (table format)
+            output_format = ctx.obj.get("format", DEFAULT_OUTPUT_FORMAT)
+            is_interactive = output_format == "table"
+
+            if is_interactive:
+                console.print(f"[yellow]Job created with ID: {job_id}[/yellow]")
+                console.print(f"[yellow]Polling every {polling_interval} seconds...[/yellow]")
+
+            while True:
+                time.sleep(polling_interval)
+
+                # Get job status
+                handler_get = OperationHandlerFactory.get_handler("sbom")
+                path_params_get, query_params_get = handler_get.build_params("getJob", (), {"job_id": job_id})
+
+                job_status = api_factory.call(
+                    "sbom",
+                    "getJob",
+                    path_params=path_params_get,
+                    query_params=query_params_get,
+                    timeout=ctx.obj.get("timeout", DEFAULT_TIMEOUT),
+                    mailto=ctx.obj.get("mailto"),
+                    base_url=base_url,
+                )
+
+                status = job_status.get("status", "unknown")
+                if is_interactive:
+                    console.print(f"[cyan]Job status: {status}[/cyan]")
+
+                # Check if job is complete
+                if status in ["completed", "complete", "success", "failed", "error"]:
+                    print_output(job_status, output_format, console=console)
+                    break
+        else:
+            # No polling, just print the result
+            print_output(result, ctx.obj.get("format", DEFAULT_OUTPUT_FORMAT), console=console)
+
+    except EcosystemsCLIError as e:
+        print_error(str(e), console=console)
+    except Exception as e:
+        print_error(f"Unexpected error: {str(e)}", console=console)

ecosystems_cli/commands/sponsors.py

@@ -0,0 +1,5 @@
+"""Commands for the sponsors API."""
+
+from ecosystems_cli.commands.generator import APICommandGenerator
+
+sponsors = APICommandGenerator.create_api_group("sponsors")

ecosystems_cli/commands/summary.py

@@ -0,0 +1,5 @@
+"""Commands for the summary API."""
+
+from ecosystems_cli.commands.generator import APICommandGenerator
+
+summary = APICommandGenerator.create_api_group("summary")

ecosystems_cli/commands/timeline.py

@@ -0,0 +1,5 @@
+"""Commands for the timeline API."""
+
+from ecosystems_cli.commands.generator import APICommandGenerator
+
+timeline = APICommandGenerator.create_api_group("timeline")

ecosystems_cli/constants.py

@@ -0,0 +1,92 @@
+"""Constants for the ecosystems CLI."""
+
+# API Configuration
+API_BASE_URL_TEMPLATE = "https://{api_name}.ecosyste.ms/api/v1"
+DEFAULT_TIMEOUT = 20
+DEFAULT_CONTENT_TYPE = "application/json"
+
+# Supported APIs
+SUPPORTED_APIS = [
+    "advisories",
+]
+
+# Output Formats
+OUTPUT_FORMATS = ["table", "json", "tsv", "jsonl"]
+DEFAULT_OUTPUT_FORMAT = "table"
+
+# Display Configuration
+JSON_THEME = "monokai"
+JSON_SYNTAX = "json"
+MAX_SELECTED_FIELDS = 2
+DEFAULT_TABLE_TITLE = "API Response"
+TABLE_HEADER_STYLE = "bold cyan"
+
+# Rich Console Styles
+STYLE_BOLD_CYAN = "bold cyan"
+STYLE_BOLD_GREEN = "bold green"
+STYLE_BOLD_YELLOW = "bold yellow"
+STYLE_BOLD_MAGENTA = "bold magenta"
+STYLE_CYAN = "cyan"
+STYLE_GREEN = "green"
+STYLE_YELLOW = "yellow"
+STYLE_MAGENTA = "magenta"
+STYLE_RED = "red"
+STYLE_BOLD_RED = "bold red"
+STYLE_BLUE = "blue"
+
+# Table Display Priority Fields
+PRIORITY_FIELDS = {
+    "advisories": ["uuid", "title", "severity", "published_at", "cvss_score"],
+    "archives": ["name", "directory", "contents"],
+    "commits": ["sha", "author", "message", "timestamp", "merge"],
+    "repos": ["full_name", "name", "description", "stars", "language"],
+    "packages": ["name", "platform", "description", "downloads", "language"],
+    "summary": ["name", "type", "count", "total", "description"],
+    "awesome": ["name", "title", "url", "description", "category"],
+    "papers": ["doi", "title", "publication_date", "mentions_count", "openalex_id"],
+    "ost": ["id", "url", "category", "language", "score"],
+    "parser": ["id", "url", "status", "created_at", "sha256"],
+    "resolver": ["id", "package_name", "registry", "status", "created_at"],
+    "sbom": ["id", "url", "status", "created_at", "sha256"],
+    "licenses": ["id", "url", "status", "created_at", "sha256"],
+    "timeline": ["actor", "event_type", "repository", "owner", "payload"],
+    "issues": ["number", "title", "state", "user", "created_at"],
+    "sponsors": ["login", "has_sponsors_listing", "sponsors_count", "sponsorships_count", "minimum_sponsorship_amount"],
+    "opencollective": ["id", "url", "name", "description", "created_at"],
+    "docker": ["id", "url", "name", "description", "created_at"],
+    "diff": ["id", "url", "name", "description", "created_at"],
+    "ruby": ["id", "url", "language", "score", "monthly_downloads"],
+}
+
+# Operations Display
+OPERATIONS_PANEL_TITLE = "Operations"
+OPERATIONS_PANEL_STYLE = "yellow"
+AVAILABLE_OPERATIONS_TITLE = "Available Operations"
+AVAILABLE_OPERATIONS_STYLE = "blue"
+OPERATION_HEADERS = {"operation": "OPERATION", "method": "METHOD", "path": "PATH", "description": "DESCRIPTION"}
+DIVIDER_WIDTH_OFFSET = 40
+SUMMARY_TRUNCATE_LENGTH = 50
+
+# Error Display
+ERROR_PREFIX = "[bold red]Error:[/bold red]"
+ERROR_PANEL_STYLE = "red"
+
+# File Patterns
+OPENAPI_FILE_EXTENSION = ".openapi.yaml"
+
+# HTTP Configuration
+HTTP_METHODS = ["get", "post", "put", "delete", "patch"]
+
+# Value Formatting
+EMPTY_DICT_DISPLAY = "{}"
+EMPTY_LIST_DISPLAY = "[]"
+MAX_INLINE_ITEMS = 3
+DICT_TRUNCATE_FORMAT = "{{...}} ({count} items)"
+LIST_TRUNCATE_FORMAT = "[...] ({count} items)"
+
+# Separators
+DEFAULT_SEPARATOR = "_"
+
+# Error Message Templates
+ERROR_API_ONLY = "This method is only available for the {api_name} API"
+ERROR_OPERATION_NOT_FOUND = "Operation '{operation_id}' not found in {api_name} API"

ecosystems_cli/exceptions.py

@@ -0,0 +1,149 @@
+"""Custom exceptions for the Ecosystems CLI."""
+
+
+class EcosystemsCLIError(Exception):
+    """Base exception for all ecosystems CLI errors."""
+
+    pass
+
+
+class APIError(EcosystemsCLIError):
+    """Base exception for API-related errors."""
+
+    pass
+
+
+class APIConnectionError(APIError):
+    """Raised when unable to connect to the API."""
+
+    pass
+
+
+class APITimeoutError(APIError):
+    """Raised when an API request times out."""
+
+    pass
+
+
+class APIHTTPError(APIError):
+    """Base exception for HTTP errors from the API."""
+
+    def __init__(self, status_code: int, message: str = None):
+        self.status_code = status_code
+        super().__init__(message or f"HTTP {status_code} error")
+
+
+class APIAuthenticationError(APIHTTPError):
+    """Raised when authentication fails (401)."""
+
+    def __init__(self, message: str = None):
+        super().__init__(401, message or "Authentication failed")
+
+
+class APINotFoundError(APIHTTPError):
+    """Raised when a resource is not found (404)."""
+
+    def __init__(self, message: str = None):
+        super().__init__(404, message or "Resource not found")
+
+
+class APIServerError(APIHTTPError):
+    """Raised when the server encounters an error (5xx)."""
+
+    def __init__(self, status_code: int = 500, message: str = None):
+        super().__init__(status_code, message or f"Server error (HTTP {status_code})")
+
+
+class APIRateLimitError(APIHTTPError):
+    """Raised when API rate limit is exceeded (429)."""
+
+    def __init__(self, limit: int = None, remaining: int = None, reset_time: str = None, retry_after: int = None):
+        self.limit = limit
+        self.remaining = remaining
+        self.reset_time = reset_time
+        self.retry_after = retry_after
+
+        message = "Rate limit exceeded."
+        if limit is not None:
+            message += f"\nLimit: {limit} requests per window"
+        if remaining is not None:
+            message += f"\nRemaining: {remaining} requests"
+        if reset_time:
+            message += f"\nReset: {reset_time}"
+        if retry_after is not None:
+            message += f"\nRetry after: {retry_after} seconds"
+        message += "\nPlease wait before retrying."
+
+        super().__init__(429, message)
+
+
+class ConfigurationError(EcosystemsCLIError):
+    """Base exception for configuration-related errors."""
+
+    pass
+
+
+class InvalidAPIError(ConfigurationError):
+    """Raised when an invalid API is specified."""
+
+    def __init__(self, api_name: str):
+        super().__init__(f"Invalid API: {api_name}")
+        self.api_name = api_name
+
+
+class MissingSpecificationError(ConfigurationError):
+    """Raised when an API specification file is missing."""
+
+    def __init__(self, api_name: str):
+        super().__init__(f"Missing specification for API: {api_name}")
+        self.api_name = api_name
+
+
+class OperationError(EcosystemsCLIError):
+    """Base exception for operation-related errors."""
+
+    pass
+
+
+class InvalidOperationError(OperationError):
+    """Raised when an invalid operation is requested."""
+
+    def __init__(self, operation_id: str):
+        super().__init__(f"Invalid operation: {operation_id}")
+        self.operation_id = operation_id
+
+
+class MissingParameterError(OperationError):
+    """Raised when a required parameter is missing."""
+
+    def __init__(self, parameter_name: str):
+        super().__init__(f"Missing required parameter: {parameter_name}")
+        self.parameter_name = parameter_name
+
+
+class InvalidParameterError(OperationError):
+    """Raised when a parameter has an invalid value."""
+
+    def __init__(self, parameter_name: str, message: str = None):
+        super().__init__(message or f"Invalid parameter: {parameter_name}")
+        self.parameter_name = parameter_name
+
+
+class DataError(EcosystemsCLIError):
+    """Base exception for data processing errors."""
+
+    pass
+
+
+class JSONParseError(DataError):
+    """Raised when JSON parsing fails."""
+
+    def __init__(self, message: str = None):
+        super().__init__(message or "Failed to parse JSON")
+
+
+class InvalidResponseFormatError(DataError):
+    """Raised when the API response has an unexpected format."""
+
+    def __init__(self, message: str = None):
+        super().__init__(message or "Invalid response format")

ecosystems_cli/helpers/click_params.py

@@ -0,0 +1,49 @@
+"""Shared utilities for building Click parameter decorators from OpenAPI parameters."""
+
+from typing import List
+
+import click
+
+
+def build_click_decorators(parameters: List[dict]) -> List:
+    """Build click decorators from OpenAPI parameters.
+
+    This utility function converts OpenAPI parameter definitions into Click
+    decorators for command-line arguments and options.
+
+    Args:
+        parameters: List of OpenAPI parameter definitions
+
+    Returns:
+        List of Click parameter decorators
+    """
+    click_decorators = []
+    for param in parameters:
+        param_name = param.get("name")
+        param_in = param.get("in")
+        param_description = param.get("description", "")
+        param_required = param.get("required", False)
+        param_schema = param.get("schema", {})
+        param_type = param_schema.get("type", "string")
+
+        python_param_name = param_name.replace("_", "-")
+
+        if param_in == "path":
+            click_decorators.append(click.argument(param_name))
+        elif param_in == "query":
+            click_type = None
+            if param_type == "integer":
+                click_type = int
+            elif param_type == "boolean":
+                click_type = bool
+
+            option_decorator = click.option(
+                f"--{python_param_name}",
+                param_name.replace("-", "_"),
+                type=click_type,
+                help=param_description,
+                required=param_required,
+            )
+            click_decorators.append(option_decorator)
+
+    return click_decorators

ecosystems_cli/helpers/flatten_dict.py

@@ -0,0 +1,15 @@
+from typing import Any, Dict, List, Tuple
+
+from ecosystems_cli.constants import DEFAULT_SEPARATOR
+
+
+def flatten_dict(d: Dict[str, Any], parent_key: str = "", sep: str = DEFAULT_SEPARATOR) -> Dict[str, Any]:
+    """Flatten a nested dictionary for TSV output."""
+    items: List[Tuple[str, Any]] = []
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.extend(flatten_dict(v, new_key, sep=sep).items())
+        else:
+            items.append((new_key, v))
+    return dict(items)

ecosystems_cli/helpers/format_value.py

@@ -0,0 +1,30 @@
+from typing import Any
+
+from ecosystems_cli.constants import (
+    DICT_TRUNCATE_FORMAT,
+    EMPTY_DICT_DISPLAY,
+    EMPTY_LIST_DISPLAY,
+    LIST_TRUNCATE_FORMAT,
+    MAX_INLINE_ITEMS,
+)
+
+
+def format_value(value: Any) -> str:
+    """Format a value for display in a table or TSV."""
+    if isinstance(value, (dict, list)):
+        # For complex objects, show a simplified representation
+        if isinstance(value, dict):
+            if len(value) == 0:
+                return EMPTY_DICT_DISPLAY
+            elif len(value) <= MAX_INLINE_ITEMS:
+                return ", ".join(f"{k}: {format_value(v)}" for k, v in value.items())
+            else:
+                return DICT_TRUNCATE_FORMAT.format(count=len(value))
+        elif isinstance(value, list):
+            if len(value) == 0:
+                return EMPTY_LIST_DISPLAY
+            elif len(value) <= MAX_INLINE_ITEMS:
+                return ", ".join(format_value(v) for v in value)
+            else:
+                return LIST_TRUNCATE_FORMAT.format(count=len(value))
+    return str(value)