compshare-cli 0.1.0__py3-none-any.whl

compshare_cli/__init__.py

@@ -0,0 +1,3 @@
+"""CompShare command-line client."""
+
+__version__ = "0.1.0"

compshare_cli/__main__.py

@@ -0,0 +1,4 @@
+from compshare_cli.cli import main
+
+if __name__ == "__main__":
+    main()

compshare_cli/actions.py

@@ -0,0 +1,71 @@
+"""Public CompShare API actions covered by the first CLI release."""
+
+INSTANCE_ACTIONS = frozenset(
+    {
+        "CheckCompShareNetOptimizer",
+        "CheckCompShareResourceCapacity",
+        "CreateCompShareInstance",
+        "DeleteCompShareStopScheduler",
+        "DescribeAvailableCompShareInstanceTypes",
+        "DescribeCompShareInstance",
+        "DescribeCompShareMachineTypeFamilies",
+        "DescribeCompShareSoftwarePort",
+        "DescribeCompShareSupportZone",
+        "DescribeModelRepositoryModels",
+        "GetCompShareInstanceMonitor",
+        "GetCompShareInstancePrice",
+        "GetCompShareInstanceUpgradePrice",
+        "GetCompShareInstanceUserPrice",
+        "GetCompShareRefundPrice",
+        "GetSoftwareURL",
+        "ModifyCompShareInstanceName",
+        "RebootCompShareInstance",
+        "ReinstallCompShareInstance",
+        "ResetCompShareInstancePassword",
+        "ResizeCompShareInstance",
+        "StartCompShareInstance",
+        "StopCompShareInstance",
+        "SwitchChargeType",
+        "TerminateCompShareInstance",
+        "UpdateCompShareInstancePorts",
+        "UpdateCompShareStopScheduler",
+    }
+)
+
+IMAGE_ACTIONS = frozenset(
+    {
+        "AddFavoriteImage",
+        "CreateCompShareCustomImage",
+        "DescribeCommunityImages",
+        "DescribeCompShareCustomImages",
+        "DescribeCompShareImages",
+        "DescribeCompShareImageShareAccounts",
+        "DescribeCompShareImageTags",
+        "DescribeCompShareSharingImages",
+        "DescribeSelfCommunityImages",
+        "DescribeUserCommunityImages",
+        "GetCompShareImageCreateProgress",
+        "ModifyCompShareImageShareAccount",
+        "PublishCompShareImage",
+        "RemoveFavoriteImage",
+        "TerminateCompShareCustomImage",
+        "UpdateCompShareImage",
+    }
+)
+
+STORAGE_ACTIONS = frozenset(
+    {
+        "AttachCompshareDisk",
+        "AttachUS3",
+        "CreateAndAttachCompshareDisk",
+        "DeleteCompshareDisk",
+        "DetachCompshareDisk",
+        "GetCompShareAttachedDiskUpgradePrice",
+        "ResizeCompShareDisk",
+    }
+)
+
+PUBLIC_ACTIONS = INSTANCE_ACTIONS | IMAGE_ACTIONS | STORAGE_ACTIONS
+
+# Documented publicly but unavailable in the production API (RetCode 161).
+UNAVAILABLE_ACTIONS = frozenset({"DescribeFavoriteImages"})

compshare_cli/api.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import time
+from typing import Any, Callable, Dict, Iterable, Optional, Sequence, Tuple
+
+import typer
+from ucloud.core import exc as ucloud_exc
+
+from compshare_cli.errors import CLIError
+from compshare_cli.i18n import tr
+from compshare_cli.output import Renderer
+from compshare_cli.runtime import Runtime
+from compshare_cli.sdk import CompShareSDK
+
+
+def invoke(
+    runtime: Runtime,
+    action: str,
+    params: Dict[str, Any],
+    *,
+    list_key: Optional[str] = None,
+    row_builder: Optional[Callable[[Dict[str, Any]], Iterable[Dict[str, Any]]]] = None,
+    columns: Optional[Sequence[Tuple[str, str]]] = None,
+    success: Optional[str] = None,
+) -> Dict[str, Any]:
+    renderer = Renderer(runtime.json_output)
+    retries = 3 if action == "DeleteCompshareDisk" else 0
+    attempt = 0
+    try:
+        while True:
+            try:
+                response = CompShareSDK(runtime.profile, runtime.region).invoke(action, params)
+                break
+            except ucloud_exc.RetCodeException as error:
+                if error.code == 8434 and attempt < retries:
+                    attempt += 1
+                    if not runtime.json_output:
+                        renderer.console.print(
+                            tr(
+                                "Resource is still detaching; retrying ({attempt}/{total})...",
+                                attempt=attempt,
+                                total=retries,
+                            )
+                        )
+                    time.sleep(2 * attempt)
+                    continue
+                raise
+    except CLIError as error:
+        renderer.error(str(error))
+        raise typer.Exit(1) from error
+    except ucloud_exc.RetCodeException as error:
+        hint = error_hint(error.action or action, error.code)
+        renderer.error(
+            _with_hint(error.message or str(error), hint),
+            details={
+                "action": error.action,
+                "ret_code": error.code,
+                "request_uuid": error.request_uuid,
+                "hint": hint,
+            },
+        )
+        raise typer.Exit(1) from error
+    except ucloud_exc.UCloudException as error:
+        renderer.error(str(error))
+        raise typer.Exit(1) from error
+    except Exception as error:  # SDK transport exceptions are not all UCloudException subclasses.
+        renderer.error(str(error))
+        raise typer.Exit(1) from error
+
+    if success:
+        renderer.success(success, response)
+    elif list_key is None and row_builder is None:
+        renderer.data(response)
+    else:
+        rows = row_builder(response) if row_builder else response.get(list_key or "", [])
+        renderer.data(response, rows=rows, columns=columns)
+    return response
+
+
+def call(runtime: Runtime, action: str, params: Dict[str, Any]) -> Dict[str, Any]:
+    """Invoke without rendering, for commands that combine multiple API calls."""
+    try:
+        return CompShareSDK(runtime.profile, runtime.region).invoke(action, params)
+    except CLIError as error:
+        Renderer(runtime.json_output).error(str(error))
+        raise typer.Exit(1) from error
+    except ucloud_exc.RetCodeException as error:
+        hint = error_hint(error.action or action, error.code)
+        Renderer(runtime.json_output).error(
+            _with_hint(error.message or str(error), hint),
+            details={
+                "action": error.action,
+                "ret_code": error.code,
+                "request_uuid": error.request_uuid,
+                "hint": hint,
+            },
+        )
+        raise typer.Exit(1) from error
+    except ucloud_exc.UCloudException as error:
+        Renderer(runtime.json_output).error(str(error))
+        raise typer.Exit(1) from error
+    except Exception as error:
+        Renderer(runtime.json_output).error(str(error))
+        raise typer.Exit(1) from error
+
+
+def error_hint(action: str, code: int) -> Optional[str]:
+    hints = {
+        ("DeleteCompshareDisk", 8434): "The disk is still detaching. Wait a moment and retry.",
+        ("AttachUS3", 8433): "Confirm that US3 is enabled for the selected region and account.",
+        ("GetCompShareInstanceMonitor", 210): (
+            "This production endpoint currently rejects instance IDs; "
+            "use the console for monitoring."
+        ),
+        ("GetCompShareInstanceMonitor", 230): (
+            "This production endpoint is currently incompatible; use the console for monitoring."
+        ),
+        ("GetSoftwareURL", 230): (
+            "This production endpoint currently rejects its action; "
+            "use instance show or the console."
+        ),
+    }
+    return tr(hints[(action, code)]) if (action, code) in hints else None
+
+
+def _with_hint(message: str, hint: Optional[str]) -> str:
+    return f"{message} {tr('Hint')}: {hint}" if hint else message

compshare_cli/cli.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import sys
+from typing import List, Optional
+
+import click
+import typer
+from typer.main import get_command
+
+from compshare_cli import __version__
+from compshare_cli.commands import image, instance, storage
+from compshare_cli.config import DEFAULT_PROFILE, ConfigStore, Profile
+from compshare_cli.errors import CLIError
+from compshare_cli.i18n import configured_language, localize_command, normalize_language, tr
+from compshare_cli.output import Renderer
+from compshare_cli.runtime import Runtime
+
+app = typer.Typer(
+    name="compshare",
+    help="Manage CompShare GPU compute from the terminal.",
+    no_args_is_help=True,
+    add_completion=False,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+app.add_typer(instance.app, name="instance")
+app.add_typer(image.app, name="image")
+app.add_typer(storage.app, name="storage")
+config_app = typer.Typer(
+    help="Manage credential profiles.",
+    invoke_without_command=True,
+    no_args_is_help=False,
+)
+app.add_typer(config_app, name="config")
+
+
+@app.callback()
+def root(
+    ctx: typer.Context,
+    profile: Optional[str] = typer.Option(
+        None,
+        "--profile",
+        metavar="NAME",
+        help="Credential profile.",
+    ),
+    json_output: bool = typer.Option(
+        False,
+        "--json",
+        help="Emit machine-readable JSON.",
+    ),
+) -> None:
+    """CompShare CLI."""
+    ctx.obj = Runtime(
+        json_output=json_output,
+        profile_name=profile,
+    )
+
+
+@config_app.callback()
+def config(
+    ctx: typer.Context,
+    name: str = typer.Option(
+        DEFAULT_PROFILE,
+        "--name",
+        help="Credential profile name.",
+    ),
+    public_key: Optional[str] = typer.Option(None, "--public-key", help="API public key."),
+    private_key: Optional[str] = typer.Option(None, "--private-key", hidden=True),
+    activate: bool = typer.Option(
+        True,
+        "--activate/--no-activate",
+        help="Make this profile the default.",
+    ),
+) -> None:
+    """Save a CompShare API credential profile."""
+    if ctx.invoked_subcommand is not None:
+        return
+    public = public_key or typer.prompt(tr("Public key"))
+    private = private_key or typer.prompt(tr("Private key"), hide_input=True)
+    ConfigStore().save_profile(
+        name,
+        Profile(public_key=public, private_key=private),
+        activate=activate,
+    )
+    Renderer(ctx.find_root().obj.json_output).success(
+        tr("Saved credential profile {name}", name=name),
+        {"ok": True, "profile": name, "active": activate},
+    )
+
+
+@config_app.command("set")
+def config_set(
+    ctx: typer.Context,
+    name: str = typer.Option(DEFAULT_PROFILE, "--name", help="Credential profile name."),
+    public_key: Optional[str] = typer.Option(None, "--public-key", help="API public key."),
+    private_key: Optional[str] = typer.Option(None, "--private-key", hidden=True),
+    activate: bool = typer.Option(
+        True, "--activate/--no-activate", help="Make this profile the default."
+    ),
+) -> None:
+    """Create or update a credential profile."""
+    public = public_key or typer.prompt(tr("Public key"))
+    private = private_key or typer.prompt(tr("Private key"), hide_input=True)
+    ConfigStore().save_profile(
+        name,
+        Profile(public_key=public, private_key=private),
+        activate=activate,
+    )
+    Renderer(ctx.find_root().obj.json_output).success(
+        tr("Saved credential profile {name}", name=name),
+        {"ok": True, "profile": name, "active": activate},
+    )
+
+
+@config_app.command("list")
+def config_list(ctx: typer.Context) -> None:
+    """List credential profiles."""
+    store = ConfigStore()
+    current = store.current_profile()
+    profiles = [{"Profile": name, "Active": name == current} for name in store.list_profiles()]
+    Renderer(ctx.find_root().obj.json_output).data(
+        {"current_profile": current, "profiles": profiles},
+        rows=profiles,
+        columns=(("Profile", "PROFILE"), ("Active", "ACTIVE")),
+    )
+
+
+@config_app.command("use")
+def config_use(ctx: typer.Context, name: str) -> None:
+    """Set the default credential profile."""
+    ConfigStore().use_profile(name)
+    Renderer(ctx.find_root().obj.json_output).success(
+        tr("Using credential profile {name}", name=name),
+        {"ok": True, "profile": name},
+    )
+
+
+@config_app.command("delete")
+def config_delete(
+    ctx: typer.Context,
+    name: str,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    """Delete a credential profile."""
+    if not yes and not typer.confirm(tr("Delete credential profile {name}?", name=name)):
+        raise typer.Abort()
+    ConfigStore().delete_profile(name)
+    Renderer(ctx.find_root().obj.json_output).success(
+        tr("Deleted credential profile {name}", name=name),
+        {"ok": True, "profile": name},
+    )
+
+
+@config_app.command("path")
+def config_path_command(ctx: typer.Context) -> None:
+    """Show the configuration file path."""
+    path = str(ConfigStore().path)
+    if ctx.find_root().obj.json_output:
+        Renderer(True).data({"path": path})
+    else:
+        typer.echo(path)
+
+
+@app.command("version")
+def version(ctx: typer.Context) -> None:
+    """Print the CLI version."""
+    if ctx.find_root().obj.json_output:
+        Renderer(True).data({"version": __version__})
+    else:
+        typer.echo(__version__)
+
+
+@app.command("lang")
+def lang(
+    ctx: typer.Context,
+    language: Optional[str] = typer.Argument(None, help="Language: zh or en."),
+) -> None:
+    """Set or show the default help language."""
+    renderer = Renderer(ctx.find_root().obj.json_output)
+    if language is None:
+        current = configured_language()
+        message = (
+            f"当前默认帮助语言：{current}"
+            if current == "zh"
+            else f"Default help language: {current}"
+        )
+        renderer.success(message, {"language": current})
+        return
+
+    selected = normalize_language(language)
+    ConfigStore().save_language(selected)
+    message = (
+        "默认帮助语言已切换为中文（zh）"
+        if selected == "zh"
+        else "Default help language set to English (en)"
+    )
+    renderer.success(message, {"ok": True, "language": selected})
+
+
+def main(args: Optional[List[str]] = None) -> None:
+    argv = list(sys.argv[1:] if args is None else args)
+    try:
+        language = configured_language()
+        command = localize_command(get_command(app), language)
+        result = command.main(args=argv, prog_name="compshare", standalone_mode=False)
+    except CLIError as error:
+        Renderer("--json" in argv).error(str(error))
+        raise SystemExit(2) from error
+    except click.ClickException as error:
+        Renderer("--json" in argv).error(error.format_message())
+        raise SystemExit(error.exit_code) from error
+    except click.Abort as error:
+        Renderer("--json" in argv).error(tr("Aborted"))
+        raise SystemExit(1) from error
+    if isinstance(result, int) and result:
+        raise SystemExit(result)
+
+
+if __name__ == "__main__":
+    main()

compshare_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI command groups."""

compshare_cli/commands/common.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import typer
+
+from compshare_cli.i18n import tr
+from compshare_cli.location import region_from_zone
+from compshare_cli.output import Renderer
+from compshare_cli.runtime import Runtime
+
+
+def runtime(ctx: typer.Context) -> Runtime:
+    value = ctx.find_root().obj
+    if not isinstance(value, Runtime):
+        raise RuntimeError("CLI runtime is not initialized")
+    return value
+
+
+def request(
+    ctx: typer.Context,
+    *,
+    zone: bool = False,
+    project_id: Optional[str] = None,
+    region_value: Optional[str] = None,
+    zone_value: Optional[str] = None,
+) -> Dict[str, Any]:
+    state = runtime(ctx)
+    resolved_zone = zone_value or (state.zone if zone else None)
+    resolved_region = region_value or (
+        region_from_zone(resolved_zone) if resolved_zone else state.region
+    )
+    payload: Dict[str, Any] = {"Region": resolved_region}
+    if zone:
+        payload["Zone"] = resolved_zone
+    if project_id:
+        payload["ProjectId"] = project_id
+    return payload
+
+
+def confirm(message: str, yes: bool) -> None:
+    if yes:
+        return
+    if not typer.confirm(tr(message)):
+        raise typer.Abort()
+
+
+def confirm_details(
+    state: Runtime,
+    title: str,
+    fields: list[tuple[str, Any]],
+    prompt: str,
+    yes: bool,
+) -> None:
+    if not state.json_output:
+        Renderer(False).details(title, fields)
+    confirm(prompt, yes)