cloudsmith-cli 1.20.0__py3-none-any.whl

cloudsmith_cli/core/api/init.py

@@ -0,0 +1,109 @@
+"""Cloudsmith API - Initialisation."""
+
+import base64
+from typing import TypeVar
+
+import click
+import cloudsmith_api
+
+from ..rest import RestClient
+
+
+def initialise_api(
+    debug=False,
+    host=None,
+    credential=None,
+    proxy=None,
+    ssl_verify=True,
+    user_agent=None,
+    headers=None,
+    rate_limit=True,
+    rate_limit_callback=None,
+    error_retry_max=None,
+    error_retry_backoff=None,
+    error_retry_codes=None,
+    error_retry_cb=None,
+):
+    """Initialise the cloudsmith_api.Configuration."""
+    # FIXME: pylint: disable=too-many-arguments
+    config = cloudsmith_api.Configuration()
+    config.debug = debug
+    config.host = host if host else config.host
+    config.proxy = proxy if proxy else config.proxy
+    config.user_agent = user_agent
+    config.headers = headers if headers else {}
+    config.rate_limit = rate_limit
+    config.rate_limit_callback = rate_limit_callback
+    config.error_retry_max = error_retry_max
+    config.error_retry_backoff = error_retry_backoff
+    config.error_retry_codes = error_retry_codes
+    config.error_retry_cb = error_retry_cb
+    config.verify_ssl = ssl_verify
+    config.client_side_validation = False
+
+    if credential:
+        if credential.auth_type == "bearer":
+            config.headers["Authorization"] = f"Bearer {credential.api_key}"
+            if config.debug:
+                click.echo("SSO access token config value set")
+        else:
+            config.api_key["X-Api-Key"] = credential.api_key
+            if config.debug:
+                click.echo("User API key config value set")
+
+    auth_header = headers and config.headers.get("Authorization")
+    if auth_header and " " in auth_header:
+        auth_type, encoded = auth_header.split(" ", 1)
+        if auth_type == "Basic":
+            decoded = base64.b64decode(encoded)
+            values = decoded.decode("utf-8")
+            config.username, config.password = values.split(":")
+
+            if config.debug:
+                click.echo("Username and password config values set")
+
+    # Important! Some of the attributes set above (e.g. error_retry_max) are not
+    # present in the cloudsmith_api.Configuration class declaration.
+    # By calling the set_default() method, we ensure that future instances of that
+    # class will include those attributes, and their (default) values.
+    cloudsmith_api.Configuration.set_default(config)
+
+    return config
+
+
+T = TypeVar("T")
+
+
+def get_api_client(cls: type[T]) -> T:
+    """Get an API client (with configuration)."""
+    config = cloudsmith_api.Configuration()
+    client = cls()
+    client.config = config
+    client.api_client.rest_client = RestClient(
+        error_retry_cb=getattr(config, "error_retry_cb", None),
+        respect_retry_after_header=getattr(config, "rate_limit", True),
+    )
+
+    user_agent = getattr(config, "user_agent", None)
+    if user_agent:
+        client.api_client.user_agent = user_agent
+
+    headers = getattr(config, "headers", None)
+    if headers:
+        for k, v in headers.items():
+            client.api_client.set_default_header(k, v)
+
+    return client
+
+
+def unset_api_key():
+    """Unset the API key."""
+    config = cloudsmith_api.Configuration()
+
+    try:
+        del config.api_key["X-Api-Key"]
+    except KeyError:
+        pass
+
+    if hasattr(cloudsmith_api.Configuration, "set_default"):
+        cloudsmith_api.Configuration.set_default(config)

cloudsmith_cli/core/api/metadata.py

@@ -0,0 +1,217 @@
+"""API - Package metadata (v2) endpoints."""
+
+import json
+from typing import Any
+
+import cloudsmith_api
+
+from .. import ratelimits, utils
+from ..pagination import PageInfo
+from ..rest import RestClient
+from .exceptions import catch_raise_api_exception
+
+
+class _MetadataApi:
+    """Small client for metadata endpoints not yet present in cloudsmith_api."""
+
+    def __init__(self):
+        self.config = cloudsmith_api.Configuration()
+        self.rest_client = RestClient(
+            error_retry_cb=getattr(self.config, "error_retry_cb", None),
+            respect_retry_after_header=getattr(self.config, "rate_limit", True),
+        )
+
+
+def get_metadata_api():
+    """Get the metadata API client."""
+    return _MetadataApi()
+
+
+def _build_url(config, *parts):
+    host = (config.host or "").rstrip("/")
+    suffix = "/".join(p.strip("/") for p in parts if p)
+    return f"{host}/v2/{suffix}/"
+
+
+def _build_headers(config):
+    """Build request headers from the configured cloudsmith_api.Configuration.
+
+    Mirrors the auth resolution performed by core/api/init.py: an Authorization
+    header (SSO bearer or Basic) takes precedence; otherwise we fall back to
+    the X-Api-Key header.
+    """
+    headers = {"Accept": "application/json", "Content-Type": "application/json"}
+    headers.update(getattr(config, "headers", None) or {})
+
+    user_agent = getattr(config, "user_agent", None)
+    if user_agent:
+        headers["User-Agent"] = user_agent
+
+    if headers.get("Authorization"):
+        headers.pop("X-Api-Key", None)
+    else:
+        api_key = (config.api_key or {}).get("X-Api-Key")
+        if api_key:
+            headers["X-Api-Key"] = api_key
+
+    return headers
+
+
+def _request(client, method, *path_parts, query_params=None, body=None):
+    url = _build_url(client.config, *path_parts)
+
+    with catch_raise_api_exception():
+        response = client.rest_client.request(
+            method,
+            url,
+            query_params=query_params,
+            headers=_build_headers(client.config),
+            body=body,
+        )
+
+    ratelimits.maybe_rate_limit(client, response.getheaders())
+    return response
+
+
+def _response_json(response):
+    if not response.data:
+        return {}
+    return json.loads(response.data)
+
+
+def list_metadata(
+    package_slug_perm: str,
+    *,
+    source_kind: str | None = None,
+    classification: str | None = None,
+    page: int | None = None,
+    page_size: int | None = None,
+):
+    """List metadata entries attached to a package.
+
+    `source_kind` and `classification` are sent as the lowercased enum name
+    the v2 API expects; the authoritative backend validates the value and
+    surfaces a 4xx for anything it does not recognise.
+
+    Returns a (results, PageInfo) tuple.
+    """
+    client = get_metadata_api()
+    api_kwargs = {}
+
+    source_kind_value = str(source_kind).strip().lower() if source_kind else ""
+    if source_kind_value:
+        api_kwargs["source_kind"] = source_kind_value
+    classification_value = str(classification).strip().lower() if classification else ""
+    if classification_value:
+        api_kwargs["classification"] = classification_value
+
+    api_kwargs.update(utils.get_page_kwargs(page=page, page_size=page_size))
+
+    response = _request(
+        client,
+        "GET",
+        "metadata",
+        "packages",
+        package_slug_perm,
+        query_params=api_kwargs or None,
+    )
+
+    payload = _response_json(response)
+    results = payload.get("results", payload) if isinstance(payload, dict) else payload
+    page_info = PageInfo.from_headers(response.getheaders())
+    return results, page_info
+
+
+def get_metadata(package_slug_perm: str, metadata_slug_perm: str):
+    """Retrieve a single metadata entry attached to a package."""
+    client = get_metadata_api()
+    response = _request(
+        client,
+        "GET",
+        "metadata",
+        "packages",
+        package_slug_perm,
+        metadata_slug_perm,
+    )
+    return _response_json(response)
+
+
+def create_metadata(
+    package_slug_perm: str,
+    *,
+    content: Any,
+    content_type: str,
+    source_identity: str,
+):
+    """Attach a new metadata entry to a package."""
+    client = get_metadata_api()
+    body = {
+        "content": content,
+        "content_type": content_type,
+        "source_identity": source_identity,
+    }
+    response = _request(
+        client, "POST", "metadata", "packages", package_slug_perm, body=body
+    )
+    return _response_json(response)
+
+
+def update_metadata(
+    package_slug_perm: str,
+    metadata_slug_perm: str,
+    *,
+    content: Any = None,
+    source_identity: str | None = None,
+):
+    """Patch an existing customer-owned metadata entry.
+
+    Only `content` and `source_identity` are mutable; the v2 API rejects
+    attempts to change `content_type`. Fields left as None are omitted from
+    the patch body so existing values are preserved.
+    """
+    client = get_metadata_api()
+    body = {}
+    if content is not None:
+        body["content"] = content
+    if source_identity is not None:
+        body["source_identity"] = source_identity
+    if not body:
+        raise ValueError(
+            "update_metadata requires at least one of content or source_identity"
+        )
+
+    response = _request(
+        client,
+        "PATCH",
+        "metadata",
+        "packages",
+        package_slug_perm,
+        metadata_slug_perm,
+        body=body,
+    )
+    return _response_json(response)
+
+
+def delete_metadata(package_slug_perm: str, metadata_slug_perm: str):
+    """Remove a customer-owned metadata entry from a package."""
+    client = get_metadata_api()
+    _request(
+        client,
+        "DELETE",
+        "metadata",
+        "packages",
+        package_slug_perm,
+        metadata_slug_perm,
+    )
+
+
+def validate_metadata(*, content: Any, content_type: str):
+    """Validate a metadata payload against its content type schema.
+
+    Hits POST /v2/metadata/validate/ which checks shape and schema without
+    persisting. Server returns 200 on success and 422 on validation failure.
+    """
+    client = get_metadata_api()
+    body = {"content": content, "content_type": content_type}
+    _request(client, "POST", "metadata", "validate", body=body)
+    return True

cloudsmith_cli/core/api/metrics.py

@@ -0,0 +1,78 @@
+"""API - Metrics endpoints."""
+
+import cloudsmith_api
+
+from .. import ratelimits
+from .exceptions import catch_raise_api_exception
+from .init import get_api_client
+
+
+def get_metrics_api():
+    """Get the repos API client."""
+    return get_api_client(cloudsmith_api.MetricsApi)
+
+
+def get_namespace_entitlements_metrics(owner=None, **kwargs):
+    """Get repository entitlements metrics."""
+    client = get_metrics_api()
+
+    api_kwargs = {}
+    api_kwargs.update(
+        {param: value for param, value in kwargs.items() if value is not None}
+    )
+
+    headers = []
+    res = None
+
+    if owner:
+        with catch_raise_api_exception():
+            res, _, headers = client.metrics_entitlements_account_list_with_http_info(
+                owner=owner, **api_kwargs
+            )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return res.tokens if res else {}
+
+
+def get_repository_entitlements_metrics(owner=None, repo=None, **kwargs):
+    """Get repository entitlements metrics."""
+    client = get_metrics_api()
+
+    api_kwargs = {}
+    api_kwargs.update(
+        {param: value for param, value in kwargs.items() if value is not None}
+    )
+
+    headers = []
+    res = None
+
+    if owner and repo:
+        with catch_raise_api_exception():
+            res, _, headers = client.metrics_entitlements_repo_list_with_http_info(
+                owner=owner, repo=repo, **api_kwargs
+            )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return res.tokens if res else {}
+
+
+def get_repository_packages_metrics(owner=None, repo=None, **kwargs):
+    """Get repository packages metrics."""
+    client = get_metrics_api()
+
+    api_kwargs = {}
+    api_kwargs.update(
+        {param: value for param, value in kwargs.items() if value is not None}
+    )
+
+    headers = []
+    res = None
+
+    if owner and repo:
+        with catch_raise_api_exception():
+            res, _, headers = client.metrics_packages_list_with_http_info(
+                owner=owner, repo=repo, **api_kwargs
+            )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return res.packages if res else {}

cloudsmith_cli/core/api/orgs.py

@@ -0,0 +1,201 @@
+"""API - Packages endpoints."""
+
+import cloudsmith_api
+
+from .. import ratelimits
+from ..pagination import PageInfo
+from .exceptions import catch_raise_api_exception
+from .init import get_api_client
+
+
+def get_orgs_api():
+    """Get the orgs API client."""
+    return get_api_client(cloudsmith_api.OrgsApi)
+
+
+def list_custom_domains(owner):
+    """List custom domains for an organization (raw SDK model dicts)."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        (
+            domains,
+            _,
+            headers,
+        ) = client.orgs_custom_domains_list_with_http_info(  # pylint: disable=no-member
+            org=owner
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return [domain.to_dict() for domain in domains]
+
+
+def list_vulnerability_policies(owner, page, page_size):
+    """List vulnerability policies in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policies, _, headers = client.orgs_vulnerability_policy_list_with_http_info(
+            org=owner, page=page, page_size=page_size
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    page_info = PageInfo.from_headers(headers)
+    return [policy.to_dict() for policy in policies], page_info
+
+
+def create_vulnerability_policy(owner, policy_config):
+    """Create a vulnerability policy in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policy, _, headers = client.orgs_vulnerability_policy_create_with_http_info(
+            org=owner, data=policy_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return policy.to_dict()
+
+
+def update_vulnerability_policy(owner, slug_perm, policy_config):
+    """Update a vulnerability policy in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        (
+            data,
+            _,
+            headers,
+        ) = client.orgs_vulnerability_policy_partial_update_with_http_info(
+            owner, slug_perm, data=policy_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.to_dict()
+
+
+def delete_vulnerability_policy(owner, slug_perm):
+    """Delete a vulnerability_policy from a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        _, _, headers = client.orgs_vulnerability_policy_delete_with_http_info(
+            owner, slug_perm
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+
+
+def list_license_policies(owner, page, page_size):
+    """List license policies in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policies, _, headers = client.orgs_license_policy_list_with_http_info(
+            org=owner, page=page, page_size=page_size
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    page_info = PageInfo.from_headers(headers)
+    return [policy.to_dict() for policy in policies], page_info
+
+
+def create_license_policy(owner, policy_config):
+    """Create a license policy in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policy, _, headers = client.orgs_license_policy_create_with_http_info(
+            org=owner, data=policy_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return policy.to_dict()
+
+
+def update_license_policy(owner, slug_perm, policy_config):
+    """Update a license policy in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policy, _, headers = client.orgs_license_policy_partial_update_with_http_info(
+            org=owner, slug_perm=slug_perm, data=policy_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return policy.to_dict()
+
+
+def delete_license_policy(owner, slug_perm):
+    """Delete a license policy from a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        _, _, headers = client.orgs_license_policy_delete_with_http_info(
+            owner, slug_perm
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+
+
+def list_deny_policies(owner, page, page_size):
+    """List deny policies in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policies, _, headers = client.orgs_deny_policy_list_with_http_info(
+            org=owner, page=page, page_size=page_size
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    page_info = PageInfo.from_headers(headers)
+    return [policy.to_dict() for policy in policies], page_info
+
+
+def create_deny_policy(owner, policy_config):
+    """Create a deny policy in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policy, _, headers = client.orgs_deny_policy_create_with_http_info(
+            org=owner, data=policy_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return policy.to_dict()
+
+
+def get_deny_policy(owner, slug_perm):
+    """Get a deny policy from a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policy, _, headers = client.orgs_deny_policy_read_with_http_info(
+            org=owner, slug_perm=slug_perm
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return policy.to_dict()
+
+
+def update_deny_policy(owner, slug_perm, policy_config):
+    """Update a deny policy in a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        policy, _, headers = client.orgs_deny_policy_partial_update_with_http_info(
+            org=owner, slug_perm=slug_perm, data=policy_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return policy.to_dict()
+
+
+def delete_deny_policy(owner, slug_perm):
+    """Delete a deny policy from a namespace."""
+    client = get_orgs_api()
+
+    with catch_raise_api_exception():
+        _, _, headers = client.orgs_deny_policy_delete_with_http_info(owner, slug_perm)
+
+    ratelimits.maybe_rate_limit(client, headers)