cloudsmith-cli 1.20.0__py3-none-any.whl

cloudsmith_cli/cli/exceptions.py

@@ -0,0 +1,215 @@
+"""CLI - Exceptions."""
+
+import collections
+import contextlib
+import sys
+
+import click
+
+from ..core.api.exceptions import ApiException
+from ..core.keyring import get_access_token
+
+
+@contextlib.contextmanager
+def handle_api_exceptions(
+    ctx, opts, context_msg=None, nl=False, exit_on_error=True, reraise_on_error=False
+):
+    """Context manager that handles API exceptions."""
+    # flake8: ignore=C901
+
+    # Use stderr for messages if the output is something else (e.g.  # JSON)
+    is_json_output = getattr(opts, "output", None) in ("json", "pretty_json")
+    use_stderr = is_json_output
+
+    try:
+        yield
+    except ApiException as exc:
+        context_msg = context_msg or "Failed to perform operation!"
+        detail, fields = get_details(exc)
+        hint = get_error_hint(ctx, opts, exc)
+
+        if is_json_output:
+            # Construct JSON error object
+            error_data = {
+                "detail": detail or exc.status_description,
+                "help": {
+                    "context": context_msg,
+                    "hint": hint,
+                },
+                "meta": {
+                    "code": exc.status,
+                    "description": exc.status_description,
+                },
+            }
+
+            if fields:
+                error_data["fields"] = fields
+
+            # Surface push-time metadata context (validation/attach result)
+            # in the same JSON envelope so a downstream package-create or
+            # sync failure does not lose the earlier metadata signal.
+            metadata_context = getattr(opts, "push_metadata_info", None)
+            if metadata_context is not None:
+                error_data["metadata_attachment"] = metadata_context
+
+            # Print to stdout
+            import json
+
+            click.echo(
+                json.dumps(
+                    error_data, indent=4 if opts.output == "pretty_json" else None
+                )
+            )
+
+        else:
+            # Standard CLI output to stderr (or interleaved if output != pretty, but we force use_stderr now)
+            if nl:
+                click.echo(err=use_stderr)
+                click.secho("ERROR: ", fg="red", nl=False, err=use_stderr)
+            else:
+                click.secho("ERROR", fg="red", err=use_stderr)
+
+            click.secho(
+                "%(context)s (status: %(code)s - %(code_text)s)"
+                % {
+                    "context": context_msg,
+                    "code": exc.status,
+                    "code_text": exc.status_description,
+                },
+                fg="red",
+                err=use_stderr,
+            )
+
+            if detail or fields:
+                click.echo(err=use_stderr)
+
+                if detail:
+                    click.secho(
+                        "Detail: %(detail)s"
+                        % {"detail": click.style(detail, fg="red", bold=False)},
+                        bold=True,
+                        err=use_stderr,
+                    )
+
+                if fields:
+                    for k, v in fields.items():
+                        field = "%s Field" % k.capitalize()
+
+                        # Flatten list/tuple error messages for text output
+                        if isinstance(v, (list, tuple)):
+                            v = " ".join(v)
+
+                        click.secho(
+                            "%(field)s: %(message)s"
+                            % {
+                                "field": click.style(field, bold=True),
+                                "message": click.style(v, fg="red"),
+                            },
+                            err=use_stderr,
+                        )
+
+            if hint:
+                click.echo(
+                    f"Hint: {click.style(hint, fg='yellow')}",
+                    err=use_stderr,
+                )
+
+            if opts.verbose and not opts.debug:
+                if exc.headers:
+                    click.echo(err=use_stderr)
+                    click.echo("Headers in Reply:", err=use_stderr)
+                    for k, v in exc.headers.items():
+                        click.echo(f"{k} = {v}", err=use_stderr)
+
+        if reraise_on_error:
+            raise
+
+        if exit_on_error:
+            ctx.exit(exc.status or 1)
+
+
+def get_details(exc):
+    """Get the details from the exception."""
+    detail = None
+    fields = collections.OrderedDict()
+
+    if exc.detail:
+        detail = exc.detail
+
+    if exc.fields:
+        for k, v in exc.fields.items():
+            try:
+                field_detail = v["detail"]
+            except (TypeError, KeyError):
+                field_detail = v
+
+            if k == "non_field_errors":
+                # Ensure we handle list/tuple for non_field_errors details joining
+                if isinstance(field_detail, (list, tuple)):
+                    field_detail = " ".join(field_detail)
+
+                if detail:
+                    detail += " " + field_detail
+                else:
+                    detail = field_detail
+                continue
+
+            fields[k] = field_detail
+
+    return detail, fields
+
+
+def get_error_hint(ctx, opts, exc):
+    """Get a hint to show to the user (if any)."""
+    module = sys.modules[__name__]
+    get_specific_error_hint = getattr(module, "get_%s_error_hint" % exc.status, None)
+    if get_specific_error_hint:
+        return get_specific_error_hint(ctx, opts, exc)
+    return None
+
+
+def get_401_error_hint(ctx, opts, exc):
+    """Get the hint for a 401/Unauthorised error."""
+    # pylint: disable=unused-argument
+    if opts.api_key:
+        return (
+            "Since you have an API key set, this probably means "
+            "you don't have the permission to perform this action."
+        )
+
+    access_token = get_access_token(opts.api_host)
+    if access_token:
+        return "Since you have an SSO access token set, this probably means that it has expired. Try getting a new token with 'cloudsmith auth', then try again."
+
+    if ctx.info_name == "token":
+        # This is already the token command
+        return (
+            "The login failed - Either your email address and/or "
+            "your password was incorrect. Please check them and "
+            "try again!"
+        )
+
+    return (
+        "You don't have an API key or access token set, but it seems this action "
+        "requires authentication - Try getting your API key via "
+        "'cloudsmith token', or access token via 'cloudsmith auth', then try again."
+    )
+
+
+def get_404_error_hint(ctx, opts, exc):
+    """Get the hint for a 404/NotFound error."""
+    # pylint: disable=unused-argument
+    # pylint: disable=fixme
+    # TODO(ls): Expand this to be contextual (we could look at the
+    # arguments for the command).
+    return "This usually means the user/org is wrong or not visible."
+
+
+def get_500_error_hint(ctx, opts, exc):
+    """Get the hint for a 500/InternalServerError error."""
+    # pylint: disable=unused-argument
+    return (
+        "This usually means the Cloudsmith service is encountering "
+        "issues, either with this specific command or as a whole. "
+        "Please accept our apologies and try again later."
+    )

cloudsmith_cli/cli/metadata_common.py

@@ -0,0 +1,146 @@
+"""Shared CLI helpers for package metadata content."""
+
+import json
+import os
+from dataclasses import dataclass, replace
+from typing import Any
+
+import click
+
+from ..core.version import get_version as get_cli_version
+
+
+@dataclass(frozen=True)
+class ResolvedMetadata:
+    """Metadata content resolved from CLI options."""
+
+    provided: bool
+    content: dict[str, Any] | None
+    content_type: str | None = None
+    source_identity: str | None = None
+    content_file: str | None = None
+    source_label: str | None = None
+
+
+class MetadataContentError(click.ClickException):
+    """Raised when supplied metadata content is not a valid JSON object."""
+
+    def __init__(self, message, *, source_label=None):
+        super().__init__(message)
+        self.source_label = source_label
+
+
+def default_metadata_source_identity() -> str:
+    """Return the default value for metadata source identity options."""
+    return f"cloudsmith-cli@{get_cli_version()}"
+
+
+def source_label_for(content_file):
+    """Return a human-readable label for a metadata content source."""
+    if content_file == "-":
+        return "stdin"
+    if content_file:
+        return os.path.basename(content_file)
+    return "inline"
+
+
+def _json_type_name(value):
+    if value is None:
+        return "null"
+    if isinstance(value, list):
+        return "array"
+    if isinstance(value, str):
+        return "string"
+    if isinstance(value, bool):
+        return "boolean"
+    if isinstance(value, (int, float)):
+        return "number"
+    return type(value).__name__
+
+
+def _parse_json_object(raw, source_label):
+    try:
+        content = json.loads(raw)
+    except ValueError as exc:
+        raise MetadataContentError(
+            f"Invalid JSON in {source_label}: {exc}",
+            source_label=source_label,
+        ) from exc
+
+    if not isinstance(content, dict):
+        raise MetadataContentError(
+            "Metadata content must be a JSON object. Found "
+            f"{_json_type_name(content)}.",
+            source_label=source_label,
+        )
+
+    return content
+
+
+def resolve_metadata_content(
+    *,
+    content_file: str | None,
+    inline_content: str | None,
+    required: bool,
+    file_option_name: str,
+    content_option_name: str,
+) -> ResolvedMetadata:
+    """Resolve metadata content options into a parsed JSON object."""
+    if content_file is not None and inline_content is not None:
+        raise click.UsageError(
+            f"{file_option_name} and {content_option_name} are mutually exclusive."
+        )
+
+    if content_file is not None:
+        source_label = source_label_for(content_file)
+        if content_file == "-":
+            raw = click.get_text_stream("stdin").read()
+        else:
+            with open(content_file, encoding="utf-8") as fh:
+                raw = fh.read()
+    elif inline_content is not None:
+        source_label = source_label_for(None)
+        raw = inline_content
+    elif required:
+        raise click.UsageError(
+            f"One of {file_option_name} or {content_option_name} is required."
+        )
+    else:
+        return ResolvedMetadata(provided=False, content=None)
+
+    return ResolvedMetadata(
+        provided=True,
+        content=_parse_json_object(raw, source_label),
+        content_file=content_file,
+        source_label=source_label,
+    )
+
+
+def require_metadata_content_type(
+    *,
+    content_type: str | None,
+    content_provided: bool,
+    option_name: str,
+) -> None:
+    """Require content type when metadata content has been supplied."""
+    if content_provided and not content_type:
+        raise click.UsageError(
+            f"{option_name} is required when metadata content is supplied."
+        )
+
+
+def attach_metadata_options(
+    metadata: ResolvedMetadata,
+    *,
+    content_type: str | None,
+    source_identity: str | None,
+) -> ResolvedMetadata:
+    """Return a resolved payload with content type and source identity attached."""
+    if not metadata.provided:
+        return metadata
+
+    return replace(
+        metadata,
+        content_type=content_type,
+        source_identity=source_identity or default_metadata_source_identity(),
+    )

cloudsmith_cli/cli/saml.py

@@ -0,0 +1,109 @@
+from urllib.parse import urlencode
+
+import requests
+
+from ..core.api.exceptions import ApiException
+
+
+def create_configured_session(opts):
+    """
+    Create a requests session configured with the options from opts.
+    """
+    session = requests.Session()
+
+    if hasattr(opts, "api_ssl_verify") and opts.api_ssl_verify is not None:
+        session.verify = opts.api_ssl_verify
+
+    if hasattr(opts, "api_proxy") and opts.api_proxy:
+        session.proxies = {"http": opts.api_proxy, "https": opts.api_proxy}
+
+    if hasattr(opts, "api_user_agent") and opts.api_user_agent:
+        session.headers.update({"User-Agent": opts.api_user_agent})
+
+    if hasattr(opts, "api_headers") and opts.api_headers:
+        session.headers.update(opts.api_headers)
+
+    return session
+
+
+def get_idp_url(api_host, owner, session):
+    org_saml_url = "{api_host}/orgs/{owner}/saml/?{params}".format(
+        api_host=api_host,
+        owner=owner,
+        params=urlencode({"redirect_url": "http://localhost:12400"}),
+    )
+
+    org_saml_response = session.get(org_saml_url, timeout=30)
+
+    try:
+        org_saml_response.raise_for_status()
+    except requests.RequestException as exc:
+        raise ApiException(
+            org_saml_response.status_code,
+            headers=exc.response.headers,
+            body=exc.response.content,
+        )
+
+    return org_saml_response.json().get("redirect_url")
+
+
+def exchange_2fa_token(api_host, two_factor_token, totp_token, session):
+    exchange_data = {"two_factor_token": two_factor_token, "totp_token": totp_token}
+    exchange_url = f"{api_host}/user/two-factor/"
+
+    headers = {
+        "Authorization": "Bearer {two_factor_token}".format(
+            two_factor_token=two_factor_token
+        )
+    }
+
+    exchange_response = session.post(
+        exchange_url,
+        data=exchange_data,
+        headers=headers,
+        timeout=30,
+    )
+
+    try:
+        exchange_response.raise_for_status()
+    except requests.RequestException as exc:
+        raise ApiException(
+            exchange_response.status_code,
+            headers=exc.response.headers,
+            body=exc.response.content,
+        )
+
+    exchange_data = exchange_response.json()
+    access_token = exchange_data.get("access_token")
+    refresh_token = exchange_data.get("refresh_token")
+
+    return (access_token, refresh_token)
+
+
+def refresh_access_token(api_host, access_token, refresh_token, session):
+    data = {"refresh_token": refresh_token}
+    url = f"{api_host}/user/refresh-token/"
+
+    headers = {"Authorization": f"Bearer {access_token}"}
+
+    response = session.post(
+        url,
+        data=data,
+        headers=headers,
+        timeout=30,
+    )
+
+    try:
+        response.raise_for_status()
+    except requests.RequestException as exc:
+        raise ApiException(
+            response.status_code,
+            headers=exc.response.headers,
+            body=exc.response.content,
+        )
+
+    response_data = response.json()
+    access_token = response_data.get("access_token")
+    refresh_token = response_data.get("refresh_token")
+
+    return (access_token, refresh_token)

cloudsmith_cli/cli/table.py

@@ -0,0 +1,59 @@
+"""Core rate limit utilities."""
+
+from collections import namedtuple
+
+# pylint: disable=ungrouped-imports
+import click
+from click.utils import strip_ansi
+
+Table = namedtuple(
+    "Table", ["headers", "plain_headers", "rows", "plain_rows", "column_widths"]
+)
+
+
+def make_table(headers=None, rows=None):
+    """Make a table from headers and rows."""
+    if callable(headers):
+        headers = headers()
+    if callable(rows):
+        rows = rows()
+    assert isinstance(headers, list)
+    assert isinstance(rows, list)
+    assert all(len(row) == len(headers) for row in rows)
+
+    plain_headers = [strip_ansi(str(v)) for v in headers]
+    plain_rows = [row for row in [strip_ansi(str(v)) for v in rows]]
+
+    plain_headers = []
+    column_widths = []
+
+    for k, v in enumerate(headers):
+        v = str(v)
+        plain = strip_ansi(v)
+        plain_headers.append(plain)
+        column_widths.append(len(plain))
+
+        if len(v) == len(plain):
+            # Value was unstyled, make it bold
+            v = click.style(v, bold=True)
+
+        headers[k] = v
+
+    plain_rows = []
+    for row in rows:
+        plain_row = []
+        for k, v in enumerate(row):
+            v = str(v)
+            plain = strip_ansi(v)
+            plain_row.append(plain)
+            column_widths[k] = max(column_widths[k], len(plain))
+
+        plain_rows.append(plain_row)
+
+    return Table(
+        headers=headers,
+        plain_headers=plain_headers,
+        rows=rows,
+        plain_rows=plain_rows,
+        column_widths=column_widths,
+    )

cloudsmith_cli/cli/types.py

@@ -0,0 +1,14 @@
+"""CLI/Commands - Custom types."""
+
+import os
+
+import click
+
+
+class ExpandPath(click.Path):
+    """Extends Path to provide expanded user $HOME paths."""
+
+    def convert(self, value, *args, **kwargs):  # pylint: disable=arguments-differ
+        """Take a path with $HOME variables and resolve it to full path."""
+        value = os.path.expanduser(value)
+        return super().convert(value, *args, **kwargs)