cloudsmith-cli 1.20.0__py3-none-any.whl

cloudsmith_cli/core/api/packages.py

@@ -0,0 +1,309 @@
+"""API - Packages endpoints."""
+
+import inspect
+
+import cloudsmith_api
+from cloudsmith_api.models import PackageQuarantineRequest
+
+from .. import ratelimits, utils
+from ..pagination import PageInfo
+from .exceptions import catch_raise_api_exception
+from .init import get_api_client
+
+
+def get_packages_api():
+    """Get the packages API client."""
+    return get_api_client(cloudsmith_api.PackagesApi)
+
+
+def make_create_payload(**kwargs):
+    """Create payload for upload/check-upload operations."""
+    payload = {}
+    # Add non-empty arguments
+    for k, v in kwargs.items():
+        if v is not None:
+            payload[k] = v
+
+    return payload
+
+
+def create_package(package_format, owner, repo, **kwargs):
+    """Create a new package in a repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        upload = getattr(client, "packages_upload_%s_with_http_info" % package_format)
+
+        data, _, headers = upload(
+            owner=owner, repo=repo, data=make_create_payload(**kwargs)
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.slug_perm, data.slug
+
+
+def validate_create_package(package_format, owner, repo, **kwargs):
+    """Validate parameters for creating a package."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        check = getattr(
+            client, "packages_validate_upload_%s_with_http_info" % package_format
+        )
+
+        _, _, headers = check(
+            owner=owner, repo=repo, data=make_create_payload(**kwargs)
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return True
+
+
+def copy_package(owner, repo, identifier, destination):
+    """Copy a package to another repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_copy_with_http_info(
+            owner=owner,
+            repo=repo,
+            identifier=identifier,
+            data={"destination": destination},
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.slug_perm, data.slug
+
+
+def move_package(owner, repo, identifier, destination):
+    """Move a package to another repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_move_with_http_info(
+            owner=owner,
+            repo=repo,
+            identifier=identifier,
+            data={"destination": destination},
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.slug_perm, data.slug
+
+
+def delete_package(owner, repo, identifier):
+    """Delete a package in a repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        _, _, headers = client.packages_delete_with_http_info(
+            owner=owner, repo=repo, identifier=identifier
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return True
+
+
+def resync_package(owner, repo, identifier):
+    """Resync a package in a repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_resync_with_http_info(
+            owner=owner, repo=repo, identifier=identifier
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.slug_perm, data.slug
+
+
+def quarantine_package(owner, repo, identifier):
+    """Quarantine a package."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_quarantine_with_http_info(
+            owner=owner, repo=repo, identifier=identifier
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.slug_perm, data.slug
+
+
+def quarantine_restore_package(owner, repo, identifier):
+    """Restorea a package from quarantine."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_quarantine_with_http_info(
+            owner=owner,
+            repo=repo,
+            identifier=identifier,
+            data=PackageQuarantineRequest(restore=True),
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.slug_perm, data.slug
+
+
+def tag_package(owner, repo, identifier, data):
+    """Manage tags for a package in a repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_tag_with_http_info(
+            owner=owner, repo=repo, identifier=identifier, data=data
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.tags, data.tags_immutable
+
+
+def get_package_status(owner, repo, identifier):
+    """Get the status for a package in a repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_status_with_http_info(
+            owner=owner, repo=repo, identifier=identifier
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+
+    # pylint: disable=no-member
+    # Pylint detects the returned value as a tuple
+    return (
+        data.is_sync_completed,
+        data.is_sync_failed,
+        data.sync_progress,
+        data.status_str,
+        data.stage_str,
+        data.status_reason,
+    )
+
+
+def get_package_dependencies(owner, repo, identifier, **kwargs):
+    """Get the direct dependencies for a package in a repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_dependencies_with_http_info(
+            owner=owner, repo=repo, identifier=identifier, **kwargs
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+
+    # pylint: disable=no-member
+    # Pylint detects the returned value as a tuple
+    page_info = PageInfo.from_headers(headers)
+    return [x.to_dict() for x in data.dependencies], page_info
+
+
+def get_package_tags(owner, repo, identifier):
+    """Get the tags for a package in a repository."""
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_read_with_http_info(
+            owner=owner, repo=repo, identifier=identifier
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+
+    # pylint: disable=no-member
+    # Pylint detects the returned value as a tuple
+    return (data.tags, data.tags_immutable)
+
+
+def get_package_slug_perm(owner, repo, identifier):
+    """Resolve a package's permanent slug from owner/repo/identifier.
+
+    Used by metadata commands that address packages by slug_perm.
+    """
+    client = get_packages_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_read_with_http_info(
+            owner=owner, repo=repo, identifier=identifier
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+
+    # pylint: disable=no-member
+    return data.slug_perm
+
+
+def list_packages(owner, repo, **kwargs):
+    """List packages for a repository."""
+    client = get_packages_api()
+
+    api_kwargs = {}
+    api_kwargs.update(utils.get_page_kwargs(**kwargs))
+    api_kwargs.update(utils.get_query_kwargs(**kwargs))
+    api_kwargs.update(utils.get_sort_kwargs(**kwargs))
+
+    with catch_raise_api_exception():
+        data, _, headers = client.packages_list_with_http_info(
+            owner=owner, repo=repo, **api_kwargs
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    page_info = PageInfo.from_headers(headers)
+    return [x.to_dict() for x in data], page_info
+
+
+def get_package_formats():
+    """Get the list of available package formats and parameters."""
+
+    # pylint: disable=fixme
+    # HACK: This obviously isn't great, and it is subject to change as
+    # the API changes, but it'll do for now as a interim method of
+    # introspection to get the parameters we need.
+    def get_parameters(cls):
+        """Build parameters for a package format."""
+        params = {}
+
+        # Create a dummy instance so we can check if a parameter is required.
+        # As with the rest of this function, this is obviously hacky. We'll
+        # figure out a way to pull this information in from the API later.
+        dummy_kwargs = {k: "dummy" for k in cls.swagger_types}
+        instance = cls(**dummy_kwargs)
+
+        for k, v in cls.swagger_types.items():
+            attr = getattr(cls, k)
+            docs = [
+                doc.strip() for doc in attr.__doc__.strip().split("\n") if doc.strip()
+            ]
+            doc = (docs[1] if docs[1] else docs[0]).strip()
+
+            try:
+                setattr(instance, k, None)
+                required = False
+            except ValueError:
+                required = True
+
+            params[cls.attribute_map.get(k)] = {
+                "type": v,
+                "help": doc,
+                "required": required,
+            }
+
+        return params
+
+    return {
+        key.replace("PackageUploadRequest", "").lower(): get_parameters(cls)
+        for key, cls in inspect.getmembers(cloudsmith_api.models)
+        if "PackageUploadRequest" in key
+    }
+
+
+def get_package_format_names(predicate=None):
+    """Get names for available package formats."""
+    return [
+        k for k, v in get_package_formats().items() if not predicate or predicate(k, v)
+    ]
+
+
+def get_package_format_names_with_distros():
+    """Get names for package formats that support distributions."""
+    return get_package_format_names(lambda k, v: "distribution" in v)

cloudsmith_cli/core/api/quota.py

@@ -0,0 +1,64 @@
+"""API - Quota endpoints."""
+
+import cloudsmith_api
+
+from .. import ratelimits
+from .exceptions import catch_raise_api_exception
+from .init import get_api_client
+
+
+def get_quota_api():
+    """Get the Quota API client."""
+    return get_api_client(cloudsmith_api.QuotaApi)
+
+
+def quota_limits(owner=None, oss=False, **kwargs):
+    """Get Quota for namespace"""
+    client = get_quota_api()
+
+    api_kwargs = {}
+    api_kwargs.update(
+        {param: value for param, value in kwargs.items() if value is not None}
+    )
+
+    if oss:
+        if hasattr(client, "quota_oss_read_with_http_info"):
+            with catch_raise_api_exception():
+                res, _, headers = client.quota_oss_read_with_http_info(
+                    owner=owner, **api_kwargs
+                )
+    elif not oss:
+        if hasattr(client, "quota_read_with_http_info"):
+            with catch_raise_api_exception():
+                res, _, headers = client.quota_read_with_http_info(
+                    owner=owner, **api_kwargs
+                )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return res if not res else res
+
+
+def quota_history(owner=None, oss=False, **kwargs):
+    """Get Quota history for namespace"""
+    client = get_quota_api()
+
+    api_kwargs = {}
+    api_kwargs.update(
+        {param: value for param, value in kwargs.items() if value is not None}
+    )
+
+    if oss:
+        if hasattr(client, "quota_oss_history_read_with_http_info"):
+            with catch_raise_api_exception():
+                res, _, headers = client.quota_oss_history_read_with_http_info(
+                    owner=owner, **api_kwargs
+                )
+    elif not oss:
+        if hasattr(client, "quota_history_read_with_http_info"):
+            with catch_raise_api_exception():
+                res, _, headers = client.quota_history_read_with_http_info(
+                    owner=owner, **api_kwargs
+                )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return res if not res else res

cloudsmith_cli/core/api/rates.py

@@ -0,0 +1,28 @@
+"""API - Status endpoints."""
+
+import cloudsmith_api
+
+from .. import ratelimits
+from ..ratelimits import RateLimitsInfo
+from .exceptions import catch_raise_api_exception
+from .init import get_api_client
+
+
+def get_rates_api():
+    """Get the status API client."""
+    return get_api_client(cloudsmith_api.RatesApi)
+
+
+def get_rate_limits():
+    """Retrieve status (and optionally) version from the API."""
+    client = get_rates_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.rates_limits_list_with_http_info()
+
+    ratelimits.maybe_rate_limit(client, headers)
+
+    return {
+        k: RateLimitsInfo.from_dict(v)
+        for k, v in data.to_dict().get("resources", {}).items()
+    }

cloudsmith_cli/core/api/repos.py

@@ -0,0 +1,81 @@
+"""API - Packages endpoints."""
+
+import cloudsmith_api
+
+from .. import ratelimits, utils
+from ..pagination import PageInfo
+from .exceptions import catch_raise_api_exception
+from .init import get_api_client
+
+
+def get_repos_api():
+    """Get the repos API client."""
+    return get_api_client(cloudsmith_api.ReposApi)
+
+
+def list_repos(owner=None, **kwargs):
+    """List repositories in a namespace."""
+    client = get_repos_api()
+
+    api_kwargs = {}
+    api_kwargs.update(utils.get_page_kwargs(**kwargs))
+
+    if owner:
+        repo = kwargs.get("repo", None)
+        if repo is not None:
+            if hasattr(client, "repos_read_with_http_info"):
+                with catch_raise_api_exception():
+                    res, _, headers = client.repos_read_with_http_info(owner, repo)
+                    res = [res]
+        else:
+            api_kwargs["owner"] = owner
+
+            if hasattr(client, "repos_namespace_list_with_http_info"):
+                with catch_raise_api_exception():
+                    res, _, headers = client.repos_namespace_list_with_http_info(
+                        **api_kwargs
+                    )
+    else:
+        if hasattr(client, "repos_user_list_with_http_info"):
+            with catch_raise_api_exception():
+                res, _, headers = client.repos_user_list_with_http_info(**api_kwargs)
+
+    ratelimits.maybe_rate_limit(client, headers)
+    page_info = PageInfo.from_headers(headers)
+    return [x.to_dict() for x in res], page_info
+
+
+def create_repo(owner, repo_config):
+    """Create a repository in a namespace."""
+    client = get_repos_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.repos_create_with_http_info(
+            owner=owner, data=repo_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.to_dict()
+
+
+def update_repo(owner, repo, repo_config):
+    """Update a repo in a namespace."""
+    client = get_repos_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.repos_partial_update_with_http_info(
+            owner, repo, data=repo_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.to_dict()
+
+
+def delete_repo(owner, repo):
+    """Delete a repo from a namespace."""
+    client = get_repos_api()
+
+    with catch_raise_api_exception():
+        _, _, headers = client.repos_delete_with_http_info(owner, repo)
+
+    ratelimits.maybe_rate_limit(client, headers)

cloudsmith_cli/core/api/status.py

@@ -0,0 +1,27 @@
+"""API - Status endpoints."""
+
+import cloudsmith_api
+
+from .. import ratelimits
+from .exceptions import catch_raise_api_exception
+from .init import get_api_client
+
+
+def get_status_api():
+    """Get the status API client."""
+    return get_api_client(cloudsmith_api.StatusApi)
+
+
+def get_status(with_version=False):
+    """Retrieve status (and optionally) version from the API."""
+    client = get_status_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.status_check_basic_with_http_info()
+
+    ratelimits.maybe_rate_limit(client, headers)
+
+    if with_version:
+        return data.detail, data.version
+
+    return data.detail

cloudsmith_cli/core/api/upstreams.py

@@ -0,0 +1,72 @@
+"""API - Packages endpoints."""
+
+import cloudsmith_api
+
+from ...core import utils
+from .. import ratelimits
+from ..pagination import PageInfo
+from .exceptions import catch_raise_api_exception
+from .init import get_api_client
+
+
+def get_upstreams_api():
+    """Get the upstreams API client."""
+    return get_api_client(cloudsmith_api.ReposApi)
+
+
+def list_upstreams(owner, repo, upstream_format, page, page_size):
+    """List upstreams by format in a repo."""
+    client = get_upstreams_api()
+
+    func = getattr(client, "repos_upstream_%s_list_with_http_info" % upstream_format)
+
+    with catch_raise_api_exception():
+        upstreams, _, headers = func(
+            owner, repo, **utils.get_page_kwargs(page=page, page_size=page_size)
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    page_info = PageInfo.from_headers(headers)
+    return [upstream.to_dict() for upstream in upstreams], page_info
+
+
+def create_upstream(owner, repo, upstream_format, upstream_config):
+    """Create an upstream for a certain package format in a repo."""
+    client = get_upstreams_api()
+
+    func = getattr(client, "repos_upstream_%s_create_with_http_info" % upstream_format)
+
+    with catch_raise_api_exception():
+        upstream, _, headers = func(owner=owner, identifier=repo, data=upstream_config)
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return upstream.to_dict()
+
+
+def update_upstream(owner, repo, slug_perm, upstream_format, upstream_config):
+    """Update an upstream belonging to a repo."""
+    client = get_upstreams_api()
+
+    func = getattr(
+        client, "repos_upstream_%s_partial_update_with_http_info" % upstream_format
+    )
+
+    with catch_raise_api_exception():
+        upstream, _, headers = func(
+            owner=owner, identifier=repo, slug_perm=slug_perm, data=upstream_config
+        )
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return upstream.to_dict()
+
+
+def delete_upstream(owner, repo, upstream_format, slug_perm):
+    """Delete an upstream from a repo."""
+    client = get_upstreams_api()
+
+    func = getattr(client, "repos_upstream_%s_delete_with_http_info" % upstream_format)
+
+    with catch_raise_api_exception():
+        _, _, headers = func(owner, repo, slug_perm)
+
+    ratelimits.maybe_rate_limit(client, headers)

cloudsmith_cli/core/api/user.py

@@ -0,0 +1,109 @@
+"""API - User endpoints."""
+
+import json
+
+import cloudsmith_api
+from cloudsmith_api.rest import ApiException
+
+from .. import ratelimits
+from .exceptions import TwoFactorRequiredException, catch_raise_api_exception
+from .init import get_api_client, unset_api_key
+
+
+def get_user_api():
+    """Get the user API client."""
+    return get_api_client(cloudsmith_api.UserApi)
+
+
+def get_user_token(login, password, totp_token=None, two_factor_token=None):
+    """Retrieve user token from the API (via authentication)."""
+    client = get_user_api()
+
+    # Never use API key for the token endpoint
+    unset_api_key()
+
+    # Prepare data based on whether this is initial login or 2FA completion
+    if totp_token and two_factor_token:
+        data_dict = {
+            "totp_token": totp_token,
+            "two_factor_token": two_factor_token,
+        }
+    else:
+        data_dict = {
+            "email": login,
+            "password": password,
+        }
+
+    try:
+        data, _, headers = client.user_token_create_with_http_info(data=data_dict)
+        ratelimits.maybe_rate_limit(client, headers)
+        return data.token
+    except ApiException as e:
+        # Check for 2FA requirement
+        if e.status == 422 and e.body:
+            try:
+                response_data = json.loads(e.body)
+                if response_data.get("two_factor_required"):
+                    two_factor_token = response_data.get("two_factor_token")
+                    # Raise custom exception for 2FA requirement
+                    raise TwoFactorRequiredException(two_factor_token)
+            except (ValueError, KeyError):
+                pass
+
+        # If not 2FA, use the context manager to handle other API exceptions
+        with catch_raise_api_exception():
+            raise
+
+
+def create_user_token_saml() -> dict:
+    """Create a new user API token using SAML."""
+    client = get_user_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.user_tokens_create_with_http_info()
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data
+
+
+def get_user_brief():
+    """Retrieve brief for current user (if any)."""
+    client = get_user_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.user_self_with_http_info()
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.authenticated, data.slug, data.email, data.name
+
+
+def list_user_tokens() -> list[dict]:
+    """List all user API tokens."""
+    client = get_user_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.user_tokens_list_with_http_info()
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data.results
+
+
+def refresh_user_token(token_slug: str) -> dict:
+    """Refresh user API token."""
+    client = get_user_api()
+
+    with catch_raise_api_exception():
+        data, _, headers = client.user_tokens_refresh_with_http_info(token_slug)
+
+    ratelimits.maybe_rate_limit(client, headers)
+    return data
+
+
+def get_token_metadata() -> dict | None:
+    """Retrieve metadata for the user's first API token.
+
+    Raises ApiException on failure; callers should handle gracefully.
+    """
+    if t := next(iter(list_user_tokens()), None):
+        return {"slug": t.slug_perm, "created": t.created}
+    return None