amd-oneclick-sdk 1.0.0__py3-none-any.whl

amd_oneclick_sdk/__init__.py

@@ -0,0 +1,45 @@
+"""Radeon Cloud SDK for scoped account and instance operations.
+
+Browser login issues a dedicated ``rcc_`` token.  Model-forwarding ``rc-``
+tokens are intentionally outside this SDK's resource-management trust domain.
+"""
+from .auth import AuthProgress, AuthResult, authenticate
+from .client import OneClickClient, RadeonCloudClient
+from .errors import (
+    ApiError,
+    AuthenticationError,
+    AuthorizationError,
+    ConfigurationError,
+    NetworkError,
+    OneClickError,
+    ProtocolError,
+    RateLimitError,
+    TlsError,
+    UrlPolicyError,
+    WaitTimeout,
+)
+from .rcc_config import ConnectionResolution, resolve_connection_info
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "ApiError",
+    "AuthProgress",
+    "AuthResult",
+    "AuthenticationError",
+    "AuthorizationError",
+    "ConnectionResolution",
+    "ConfigurationError",
+    "NetworkError",
+    "OneClickClient",
+    "OneClickError",
+    "ProtocolError",
+    "RateLimitError",
+    "RadeonCloudClient",
+    "TlsError",
+    "UrlPolicyError",
+    "WaitTimeout",
+    "__version__",
+    "authenticate",
+    "resolve_connection_info",
+]

amd_oneclick_sdk/_cli/__init__.py

@@ -0,0 +1,7 @@
+"""Internal implementation modules for the RCC command-line interface.
+
+The supported import remains amd_oneclick_sdk.cli. This package separates
+argument parsing and top-level dispatch from device authentication, local
+profiles, read-only credits, catalog discovery, and instance lifecycle
+commands. Deferred product areas are intentionally absent from this release.
+"""

amd_oneclick_sdk/_cli/auth_commands.py

@@ -0,0 +1,225 @@
+"""Workstation authentication and account-switching commands."""
+from __future__ import annotations
+
+from ..client import OneClickClient
+from ..errors import ConfigurationError, OneClickError
+from ..rcc_config import (
+    account_names,
+    active_account_name,
+    get_account,
+    load_config,
+    remove_account,
+    resolve_connection,
+    resolve_connection_info,
+)
+from .common import _client_for, _write_json
+from .device_auth import _authorize_account
+
+
+_LOGOUT_WARNINGS = [
+    "Only the selected RCC access token is revoked.",
+    "Running instances, GPU billing, other device tokens, and web sessions are unchanged.",
+]
+
+
+def _command_auth_login(args, out, err) -> int:
+    base_url, _ = resolve_connection(
+        args.base_url,
+        "",
+        require_token=False,
+        account=getattr(args, "account", None),
+        allow_missing_account=True,
+    )
+    result, path = _authorize_account(
+        base_url=base_url,
+        device_name=args.device_name,
+        timeout=args.timeout,
+        no_browser=args.no_browser,
+        out=out,
+        err=err,
+        json_output=args.json,
+        account_name=getattr(args, "account", None),
+        derive_name=not bool(getattr(args, "account", None)),
+    )
+    if args.json:
+        _write_json(
+            {
+                **result.public_payload(),
+                "status": "authenticated",
+                "config_path": str(path),
+            },
+            out,
+        )
+    else:
+        out.write(
+            f"Authenticated as {result.user.get('email') or 'unknown user'}.\n"
+            f"Credentials saved to {path}\n"
+        )
+    return 0
+
+
+def _command_auth_status(args, out, err) -> int:
+    if getattr(args, "all", False):
+        return _command_auth_list(args, out, err, include_remote=True)
+    payload = _client_for(args).auth_status()
+    if args.json:
+        _write_json(payload, out)
+        return 0
+    user = payload.get("user") or {}
+    token = payload.get("token") or {}
+    out.write(
+        f"authenticated: {user.get('email') or 'unknown'}\n"
+        f"provider: {user.get('provider') or 'unknown'}\n"
+        f"credits: {user.get('credits', 0)}\n"
+        f"token expires: {token.get('expires_at') or 'unknown'}\n"
+    )
+    return 0
+
+
+def _command_auth_logout(args, out, err) -> int:
+    if getattr(args, "all", False):
+        if any(getattr(args, name, None) is not None for name in ("account", "base_url", "token")):
+            raise ConfigurationError("auth logout --all cannot use --account, --base-url, or --token")
+        removed = []
+        failures = []
+        for name in list(account_names()):
+            try:
+                _logout_one_account(name)
+            except OneClickError as exc:
+                failures.append({"account": name, "error": str(exc)})
+            else:
+                removed.append(name)
+        payload = {
+            "logged_out": removed,
+            "failed": failures,
+            "active_account": active_account_name() or None,
+            "warnings": list(_LOGOUT_WARNINGS),
+        }
+        if args.json:
+            _write_json(payload, out)
+        else:
+            out.write(
+                f"Revoked and removed {len(removed)} workstation login(s).\n"
+                "Warning: running resources and billing continue; other device "
+                "tokens and web sessions are unchanged.\n"
+            )
+            for failure in failures:
+                out.write(
+                    f"  {failure['account']} was kept locally: "
+                    f"{failure['error']}\n"
+                )
+        return 1 if failures else 0
+    connection = resolve_connection_info(
+        getattr(args, "base_url", None),
+        getattr(args, "token", None),
+        account=getattr(args, "account", None),
+    )
+    payload = OneClickClient(connection.base_url, connection.token).auth_logout()
+    selected = (
+        connection.account
+        if connection.token_source == f"account:{connection.account}"
+        else ""
+    )
+    if selected:
+        # A concurrent login must survive revocation of the older token.
+        remove_account(selected, expected_token=connection.token)
+    payload = {
+        **payload,
+        "account": selected or None,
+        "base_url": connection.base_url,
+        "token_source": connection.token_source,
+        "local_profile_removed": bool(selected),
+        "warnings": list(_LOGOUT_WARNINGS),
+    }
+    if args.json:
+        _write_json(payload, out)
+    else:
+        result = (
+            f"RCC token for {selected!r} was revoked and its local profile removed.\n"
+            if selected else f"RCC token for {connection.base_url} was revoked.\n"
+        )
+        out.write(
+            result +
+            "Warning: running resources and billing continue; other device tokens "
+            "and web sessions are unchanged.\n"
+        )
+    return 0
+
+
+def _logout_one_account(name: str) -> dict:
+    selected, entry = get_account(name)
+    token = str(entry.get("token") or "")
+    payload: dict = {"revoked": False}
+    if token:
+        payload = OneClickClient(str(entry.get("base_url") or ""), token).auth_logout()
+    remove_account(selected, expected_token=token)
+    return {
+        **payload,
+        "account": selected,
+        "local_profile_removed": True,
+        "warnings": list(_LOGOUT_WARNINGS),
+    }
+
+
+def _public_accounts() -> tuple[str, list[dict]]:
+    document = load_config()
+    active = str(document.get("active_account") or "")
+    rows = []
+    for name, entry in (document.get("accounts") or {}).items():
+        rows.append(
+            {
+                "name": name,
+                "active": name == active,
+                "email": str(entry.get("email") or ""),
+                "base_url": str(entry.get("base_url") or ""),
+                "expires_at": str(entry.get("expires_at") or ""),
+                "logged_in": bool(entry.get("token")),
+            }
+        )
+    return active, rows
+
+
+def _account_rows_with_remote_state() -> tuple[str, list[dict]]:
+    active, rows = _public_accounts()
+    for row in rows:
+        row["provider"] = None
+        row["credits"] = None
+        row["remote_account"] = None
+        row["remote_error"] = None
+        if not row["logged_in"]:
+            continue
+        try:
+            base_url, token = resolve_connection(account=row["name"])
+            client = OneClickClient(base_url, token)
+            account = client.account().get("account") or {}
+            row["provider"] = account.get("provider")
+            row["credits"] = account.get("credits")
+            row["remote_account"] = account
+        except OneClickError as exc:
+            row["remote_error"] = str(exc)
+    return active, rows
+
+
+def _command_auth_list(args, out, err, *, include_remote: bool = True) -> int:
+    active, rows = (
+        _account_rows_with_remote_state() if include_remote else _public_accounts()
+    )
+    if args.json:
+        _write_json({"active_account": active or None, "accounts": rows}, out)
+        return 0
+    if not rows:
+        out.write("No workstation accounts. Run 'rcc auth login'.\n")
+        return 0
+    for row in rows:
+        marker = "*" if row["active"] else " "
+        login = "logged in" if row["logged_in"] else "logged out"
+        credits = row.get("credits")
+        credit_text = "unknown" if credits is None else str(credits)
+        out.write(
+            f"{marker} {row['name']}  {row['email'] or 'unknown email'}  "
+            f"[{login}; credits={credit_text}; "
+            f"expires={row['expires_at'] or 'unknown'}]\n"
+        )
+        if row.get("remote_error"):
+            out.write(f"    remote status: {row['remote_error']}\n")
+    return 0