compshare-cli 0.3.6__tar.gz → 0.4.1__tar.gz

{compshare_cli-0.3.6/src/compshare_cli.egg-info → compshare_cli-0.4.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: compshare-cli
-Version: 0.3.6
-Summary: Command-line client for CompShare GPU compute
+Version: 0.4.1
+Summary: Command-line client for CompShare GPU compute and MiniMax H3
 Author: CompShare
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/BennielAllan/compshare-cli
@@ -25,12 +25,14 @@ Dynamic: license-file
 
 # CompShare CLI
 
-在终端管理优云智算 GPU 实例、镜像、云盘、US3 挂载和团队资源。
+在终端管理优云智算 GPU 实例、镜像、云盘、US3 挂载、独享带宽、团队资源和 MiniMax H3 视频任务。
 
 - 交互式创建实例，实时查询规格、库存和价格
 - 支持批量生命周期操作、等待状态和跨地域查询
 - 支持可断线恢复的远程任务、状态查询和增量日志读取
 - 支持社区/自定义镜像、云盘、团队额度与账单
+- 支持独享带宽询价、购买、改配、退款预估及实例 EIP 切换
+- 支持创建、查询和取消 MiniMax H3 视频任务，并查看积分套餐包与余额
 - 默认中文帮助，可切换英文；所有命令支持 JSON 输出
 - 可通过 `compshare ask` 查询产品使用和计费知识
 - 可通过 `compshare feedback` 反馈 CLI 问题和建议
@@ -61,6 +63,9 @@ compshare --profile production instance list
 ```bash
 export COMPSHARE_PUBLIC_KEY='...'
 export COMPSHARE_PRIVATE_KEY='...'
+
+# MiniMax H3 使用独立的模型 API Key
+export COMPSHARE_MINIMAX_API_KEY='sk-ml-...'
 ```
 
 CLI 使用统计和反馈与业务 API 一样，通过当前 profile 的凭证签名后发送到
@@ -77,6 +82,11 @@ compshare instance list --all
 # 连接实例
 compshare instance ssh INSTANCE_ID
 
+# MiniMax H3：先预演，再创建
+compshare --json minimax create '一只猫在海边奔跑' --dry-run
+compshare --json minimax create '一只猫在海边奔跑' --yes
+compshare --json minimax points
+
 # 查看帮助
 compshare -h
 compshare instance -h
@@ -92,6 +102,8 @@ compshare ask        产品使用和计费问答
 compshare instance   GPU 实例、规格、库存、价格和生命周期
 compshare image      平台、自定义、社区及共享镜像
 compshare storage    云盘和 US3 挂载
+compshare bandwidth  独享带宽和实例 EIP 带宽归属
+compshare minimax    MiniMax H3 视频任务和积分
 compshare team       团队、邀请、成员额度、账单和审计
 ```
 

{compshare_cli-0.3.6 → compshare_cli-0.4.1}/README.md

@@ -1,11 +1,13 @@
 # CompShare CLI
 
-在终端管理优云智算 GPU 实例、镜像、云盘、US3 挂载和团队资源。
+在终端管理优云智算 GPU 实例、镜像、云盘、US3 挂载、独享带宽、团队资源和 MiniMax H3 视频任务。
 
 - 交互式创建实例，实时查询规格、库存和价格
 - 支持批量生命周期操作、等待状态和跨地域查询
 - 支持可断线恢复的远程任务、状态查询和增量日志读取
 - 支持社区/自定义镜像、云盘、团队额度与账单
+- 支持独享带宽询价、购买、改配、退款预估及实例 EIP 切换
+- 支持创建、查询和取消 MiniMax H3 视频任务，并查看积分套餐包与余额
 - 默认中文帮助，可切换英文；所有命令支持 JSON 输出
 - 可通过 `compshare ask` 查询产品使用和计费知识
 - 可通过 `compshare feedback` 反馈 CLI 问题和建议
@@ -36,6 +38,9 @@ compshare --profile production instance list
 ```bash
 export COMPSHARE_PUBLIC_KEY='...'
 export COMPSHARE_PRIVATE_KEY='...'
+
+# MiniMax H3 使用独立的模型 API Key
+export COMPSHARE_MINIMAX_API_KEY='sk-ml-...'
 ```
 
 CLI 使用统计和反馈与业务 API 一样，通过当前 profile 的凭证签名后发送到
@@ -52,6 +57,11 @@ compshare instance list --all
 # 连接实例
 compshare instance ssh INSTANCE_ID
 
+# MiniMax H3：先预演，再创建
+compshare --json minimax create '一只猫在海边奔跑' --dry-run
+compshare --json minimax create '一只猫在海边奔跑' --yes
+compshare --json minimax points
+
 # 查看帮助
 compshare -h
 compshare instance -h
@@ -67,6 +77,8 @@ compshare ask        产品使用和计费问答
 compshare instance   GPU 实例、规格、库存、价格和生命周期
 compshare image      平台、自定义、社区及共享镜像
 compshare storage    云盘和 US3 挂载
+compshare bandwidth  独享带宽和实例 EIP 带宽归属
+compshare minimax    MiniMax H3 视频任务和积分
 compshare team       团队、邀请、成员额度、账单和审计
 ```
 

{compshare_cli-0.3.6 → compshare_cli-0.4.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "compshare-cli"
 dynamic = ["version"]
-description = "Command-line client for CompShare GPU compute"
+description = "Command-line client for CompShare GPU compute and MiniMax H3"
 readme = "README.md"
 requires-python = ">=3.9"
 license = "Apache-2.0"

{compshare_cli-0.3.6 → compshare_cli-0.4.1}/src/compshare_cli/__init__.py

@@ -1,3 +1,3 @@
 """CompShare command-line client."""
 
-__version__ = "0.3.6"
+__version__ = "0.4.1"

{compshare_cli-0.3.6 → compshare_cli-0.4.1}/src/compshare_cli/actions.py

@@ -1,4 +1,4 @@
-"""Public CompShare API actions covered by the first CLI release."""
+"""Public CompShare API actions covered by the CLI."""
 
 INSTANCE_ACTIONS = frozenset(
     {
@@ -88,7 +88,22 @@ TEAM_ACTIONS = frozenset(
     }
 )
 
-PUBLIC_ACTIONS = INSTANCE_ACTIONS | IMAGE_ACTIONS | STORAGE_ACTIONS | TEAM_ACTIONS
+BANDWIDTH_ACTIONS = frozenset(
+    {
+        "CreateCompShareShareBandwidth",
+        "DeleteCompShareShareBandwidth",
+        "DescribeCompShareShareBandwidth",
+        "GetCompShareShareBandwidthPrice",
+        "GetCompShareShareBandwidthRefundPrice",
+        "GetCompShareShareBandwidthUpgradePrice",
+        "ModifyCompShareShareBandwidth",
+        "SwitchCompShareEIPShareBandwidth",
+    }
+)
+
+PUBLIC_ACTIONS = (
+    INSTANCE_ACTIONS | IMAGE_ACTIONS | STORAGE_ACTIONS | TEAM_ACTIONS | BANDWIDTH_ACTIONS
+)
 
 # No unavailable API actions are currently exposed as placeholders.
 COMING_SOON_ACTIONS = frozenset()

{compshare_cli-0.3.6 → compshare_cli-0.4.1}/src/compshare_cli/cli.py

@@ -11,9 +11,9 @@ from typer.main import get_command
 
 from compshare_cli import __version__
 from compshare_cli.commands import ask as ask_command
+from compshare_cli.commands import bandwidth, image, instance, minimax, storage, team
 from compshare_cli.commands import doctor as doctor_command
 from compshare_cli.commands import feedback as feedback_command
-from compshare_cli.commands import image, instance, storage, team
 from compshare_cli.commands.common import confirm
 from compshare_cli.config import DEFAULT_PROFILE, ConfigStore, Profile
 from compshare_cli.errors import CLIError, ConfigError, UsageError
@@ -26,6 +26,10 @@ _TYPER_CLICK = getattr(typer_core, "_click", click)
 _TYPER_CLICK_EXCEPTIONS = getattr(_TYPER_CLICK, "exceptions", _TYPER_CLICK)
 _CLICK_EXCEPTIONS = (click.ClickException, _TYPER_CLICK_EXCEPTIONS.ClickException)
 _ABORT_EXCEPTIONS = (click.Abort, _TYPER_CLICK_EXCEPTIONS.Abort)
+_GROUP_TYPES = (click.Group, typer_core.TyperGroup)
+_OPTION_TYPES = (click.Option, typer_core.TyperOption)
+_ARGUMENT_TYPES = (click.Argument, typer_core.TyperArgument)
+_CLICK_CONTEXT = getattr(_TYPER_CLICK, "Context", click.Context)
 
 completion_init()
 
@@ -42,7 +46,7 @@ class RootGroup(typer_core.TyperGroup):
 
 app = typer.Typer(
     name="compshare",
-    help="Manage CompShare GPU compute from the terminal.",
+    help="Manage CompShare GPU compute and MiniMax H3 from the terminal.",
     cls=RootGroup,
     no_args_is_help=True,
     add_completion=False,
@@ -51,6 +55,8 @@ app = typer.Typer(
 app.add_typer(instance.app, name="instance")
 app.add_typer(image.app, name="image")
 app.add_typer(storage.app, name="storage")
+app.add_typer(bandwidth.app, name="bandwidth")
+app.add_typer(minimax.app, name="minimax")
 app.add_typer(team.app, name="team")
 config_app = typer.Typer(
     help="Manage credential profiles.",
@@ -391,7 +397,7 @@ def _command_path(command: click.Command, argv: List[str]) -> Optional[str]:
 
     path: List[str] = []
     current = command
-    while remaining and isinstance(current, click.Group):
+    while remaining and isinstance(current, _GROUP_TYPES):
         name = remaining.pop(0)
         child = current.commands.get(name)
         if child is None:
@@ -429,13 +435,13 @@ def _json_help_payload(command: click.Command, argv: List[str]) -> Dict[str, Any
             "--show-sensitive",
         }:
             continue
-        if isinstance(current, click.Group) and token in current.commands:
+        if isinstance(current, _GROUP_TYPES) and token in current.commands:
             current = current.commands[token]
             path.append(token)
 
     parameters: List[Dict[str, Any]] = []
     for parameter in current.params:
-        if isinstance(parameter, click.Option):
+        if isinstance(parameter, _OPTION_TYPES):
             parameters.append(
                 {
                     "kind": "option",
@@ -446,7 +452,7 @@ def _json_help_payload(command: click.Command, argv: List[str]) -> Dict[str, Any
                     "help": parameter.help,
                 }
             )
-        elif isinstance(parameter, click.Argument):
+        elif isinstance(parameter, _ARGUMENT_TYPES):
             parameters.append(
                 {
                     "kind": "argument",
@@ -456,11 +462,11 @@ def _json_help_payload(command: click.Command, argv: List[str]) -> Dict[str, Any
                 }
             )
     commands = []
-    if isinstance(current, click.Group):
+    if isinstance(current, _GROUP_TYPES):
         commands = [
             {"name": name, "help": child.get_short_help_str()}
-            for name in current.list_commands(click.Context(current))
-            if (child := current.get_command(click.Context(current), name)) is not None
+            for name in current.list_commands(_CLICK_CONTEXT(current))
+            if (child := current.get_command(_CLICK_CONTEXT(current), name)) is not None
             and not child.hidden
         ]
     command_name = " ".join(["compshare", *path])

compshare_cli-0.4.1/src/compshare_cli/commands/bandwidth.py

@@ -0,0 +1,452 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+import typer
+
+from compshare_cli.api import call, call_captured, collect_pages
+from compshare_cli.commands.common import confirm_details, request, runtime
+from compshare_cli.errors import UsageError
+from compshare_cli.i18n import tr
+from compshare_cli.location import locate_instances, supported_locations
+from compshare_cli.output import Renderer
+from compshare_cli.parsing import compact
+
+app = typer.Typer(help="Manage dedicated bandwidth.", no_args_is_help=True)
+
+_BANDWIDTH_COLUMNS = (
+    ("ShareBandwidthId", "BANDWIDTH ID"),
+    ("Region", "REGION"),
+    ("Zone", "ZONE"),
+    ("Bandwidth", "BANDWIDTH (Mbps)"),
+    ("Status", "STATUS"),
+    ("ChargeType", "CHARGE"),
+    ("BindEIPCount", "EIPS"),
+    ("PurchaseValue", "EXPIRES"),
+)
+_BANDWIDTH_JSON_FIELDS = (
+    "ShareBandwidthId",
+    "ResourceId",
+    "Region",
+    "Zone",
+    "Bandwidth",
+    "Status",
+    "ChargeType",
+    "Quantity",
+    "PurchaseValue",
+    "BindEIPCount",
+    "BindEIPInfo",
+    "CreateTime",
+    "UpdateTime",
+)
+_EIP_COLUMNS = (
+    ("UHostId", "INSTANCE"),
+    ("Name", "NAME"),
+    ("Zone", "ZONE"),
+    ("IP", "PUBLIC IP"),
+    ("EIPId", "EIP ID"),
+    ("Scope", "BANDWIDTH SCOPE"),
+    ("Bandwidth", "BANDWIDTH (Mbps)"),
+    ("CanSwitch", "CAN SWITCH"),
+)
+_EIP_JSON_FIELDS = tuple(key for key, _ in _EIP_COLUMNS) + (
+    "Region",
+    "ShareBandwidthId",
+    "TargetScope",
+)
+
+
+def _charge_type(value: str) -> str:
+    charge = {"month": "Month", "year": "Year"}.get(value.casefold())
+    if charge is None:
+        raise UsageError(tr("--charge must be Month or Year."))
+    return charge
+
+
+def _target_scope(value: str) -> Tuple[str, str]:
+    target = {
+        "company": ("Company", "dedicated"),
+        "dedicated": ("Company", "dedicated"),
+        "public": ("Public", "shared"),
+        "shared": ("Public", "shared"),
+    }.get(value.casefold())
+    if target is None:
+        raise UsageError(tr("--to must be dedicated or shared."))
+    return target
+
+
+def _cny(cents: Any, *, signed: bool = False) -> Optional[str]:
+    if isinstance(cents, bool) or not isinstance(cents, (int, float)):
+        return None
+    amount = Decimal(str(cents)) / 100
+    if signed and amount < 0:
+        return tr("Refund {amount} CNY", amount=f"{abs(amount):.2f}")
+    if signed and amount > 0:
+        return tr("Payment {amount} CNY", amount=f"{amount:.2f}")
+    return f"{amount:.2f} CNY"
+
+
+def _request(
+    ctx: typer.Context,
+    region: str,
+    zone: str,
+    values: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    params = request(ctx, zone=True, region_value=region, zone_value=zone)
+    params.update(values or {})
+    return params
+
+
+def _bandwidth_rows(response: Dict[str, Any]) -> Iterable[Dict[str, Any]]:
+    return response.get("CompanyShareBandwidthSet") or []
+
+
+def _eip_rows(response: Dict[str, Any]) -> Iterable[Dict[str, Any]]:
+    for host in response.get("UHostSet") or []:
+        for ip in host.get("IPSet") or []:
+            if not ip.get("IPId") or ip.get("Type") in {"Private", "Proxy"}:
+                continue
+            assignment = ip.get("ShareBandwidth") or {}
+            yield {
+                "UHostId": host.get("UHostId"),
+                "Name": host.get("Name"),
+                "Region": host.get("Region"),
+                "Zone": host.get("Zone"),
+                "IP": ip.get("IP"),
+                "EIPId": ip.get("IPId"),
+                "Scope": assignment.get("Scope", "Unknown"),
+                "ShareBandwidthId": assignment.get("ShareBandwidthId"),
+                "Bandwidth": assignment.get("Bandwidth"),
+                "CanSwitch": bool(assignment.get("CanSwitch")),
+                "TargetScope": assignment.get("TargetScope"),
+            }
+
+
+@app.command("list", help="List dedicated bandwidth resources.")
+def list_bandwidths(
+    ctx: typer.Context,
+    region: Optional[str] = typer.Option(None, "--region", help="Filter by region."),
+    zone: Optional[str] = typer.Option(None, "--zone", help="Filter by availability zone."),
+) -> None:
+    if zone is not None and region is None:
+        raise UsageError(tr("--zone requires --region."))
+    state = runtime(ctx)
+    locations = [
+        item
+        for item in supported_locations(state, request_region=region)
+        if not item.get("IsPod") and (zone is None or item.get("Zone") == zone)
+    ]
+    rows: List[Dict[str, Any]] = []
+    for location in locations:
+        location_region = str(location["Region"])
+        location_zone = str(location["Zone"])
+        response = call(
+            state,
+            "DescribeCompShareShareBandwidth",
+            _request(ctx, location_region, location_zone),
+        )
+        bandwidth = response.get("CompanyShareBandwidth")
+        if bandwidth:
+            rows.append(
+                {
+                    **dict(bandwidth),
+                    "Region": location_region,
+                    "Zone": location_zone,
+                }
+            )
+    response = {
+        "CompanyShareBandwidthSet": rows,
+        "TotalCount": len(rows),
+        "ReturnedCount": len(rows),
+    }
+    Renderer(state.json_output, state.show_sensitive).data(
+        response,
+        rows=_bandwidth_rows(response),
+        columns=_BANDWIDTH_COLUMNS,
+        json_list=True,
+        json_fields=_BANDWIDTH_JSON_FIELDS,
+    )
+
+
+@app.command("instances", help="List instance EIP bandwidth assignments.")
+def instances(
+    ctx: typer.Context,
+    ids: Optional[List[str]] = typer.Option(None, "--id", help="Instance ID; repeatable."),
+    region: Optional[str] = typer.Option(None, "--region", help="Filter by region."),
+    zone: Optional[str] = typer.Option(None, "--zone", help="Filter by availability zone."),
+) -> None:
+    if (region is None) != (zone is None):
+        raise UsageError(tr("--region and --zone must be provided together."))
+    state = runtime(ctx)
+    params = request(ctx, region_value=region)
+    params.update(
+        compact(
+            {
+                "Zone": zone,
+                "UHostIds": ids,
+                "SkipBill": True,
+                "IncludeShareBandwidth": True,
+            }
+        )
+    )
+    response = collect_pages(state, "DescribeCompShareInstance", params, "UHostSet")
+    rows = list(_eip_rows(response))
+    result = {
+        "EIPSet": rows,
+        "TotalCount": len(rows),
+        "ReturnedCount": len(rows),
+    }
+    Renderer(state.json_output, state.show_sensitive).data(
+        result,
+        rows=rows,
+        columns=_EIP_COLUMNS,
+        json_list=True,
+        json_fields=_EIP_JSON_FIELDS,
+    )
+
+
+@app.command("create", help="Purchase dedicated bandwidth after quoting the price.")
+def create(
+    ctx: typer.Context,
+    bandwidth: int = typer.Option(
+        ...,
+        "--bandwidth",
+        min=20,
+        max=10000,
+        help="Bandwidth limit in Mbps (20-10000).",
+    ),
+    charge: str = typer.Option("Month", help="Billing type: Month or Year."),
+    quantity: int = typer.Option(1, min=1, help="Billing duration for prepaid modes."),
+    region: str = typer.Option(..., "--region", help="Region for this request."),
+    zone: str = typer.Option(..., "--zone", help="Availability zone."),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Quote and show the request without purchasing bandwidth.",
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    state = runtime(ctx)
+    params = _request(
+        ctx,
+        region,
+        zone,
+        {
+            "ShareBandwidth": bandwidth,
+            "ChargeType": _charge_type(charge),
+            "Quantity": quantity,
+        },
+    )
+    quote = call(state, "GetCompShareShareBandwidthPrice", params)
+    plan = {"dry_run": dry_run, "request": params, "price": quote}
+    fields = [
+        ("ZONE", zone),
+        ("BANDWIDTH", f"{bandwidth} Mbps"),
+        ("CHARGE", params["ChargeType"]),
+        ("QUANTITY", quantity),
+        ("PRICE", _cny(quote.get("TotalPrice"))),
+    ]
+    if dry_run:
+        Renderer(state.json_output, state.show_sensitive).details(
+            "Create plan", fields, response=plan
+        )
+        return
+    confirm_details(state, "Create plan", fields, "Confirm this operation?", yes)
+    created = call(state, "CreateCompShareShareBandwidth", params)
+    result = {"price": quote, "created": created}
+    resource = created.get("CompanyShareBandwidth") or {}
+    Renderer(state.json_output, state.show_sensitive).details(
+        "Operation completed",
+        [
+            ("BANDWIDTH ID", resource.get("ShareBandwidthId")),
+            ("BANDWIDTH", f"{resource.get('Bandwidth', bandwidth)} Mbps"),
+            ("ORDER", created.get("OrderNo")),
+        ],
+        response=result,
+    )
+
+
+@app.command("resize", help="Change a dedicated bandwidth limit after quoting the price.")
+def resize(
+    ctx: typer.Context,
+    bandwidth_id: str = typer.Argument(..., help="Dedicated bandwidth ID."),
+    bandwidth: int = typer.Option(
+        ...,
+        "--bandwidth",
+        min=20,
+        max=10000,
+        help="Target bandwidth limit in Mbps (20-10000).",
+    ),
+    region: str = typer.Option(..., "--region", help="Region for this request."),
+    zone: str = typer.Option(..., "--zone", help="Availability zone."),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Quote and show the request without changing bandwidth.",
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    state = runtime(ctx)
+    params = _request(
+        ctx,
+        region,
+        zone,
+        {"ShareBandwidthId": bandwidth_id, "ShareBandwidth": bandwidth},
+    )
+    quote = call(state, "GetCompShareShareBandwidthUpgradePrice", params)
+    plan = {"dry_run": dry_run, "request": params, "price": quote}
+    fields = [
+        ("BANDWIDTH ID", bandwidth_id),
+        ("ZONE", zone),
+        ("TARGET BANDWIDTH", f"{bandwidth} Mbps"),
+        ("PRICE", _cny(quote.get("TotalPrice"), signed=True)),
+    ]
+    if dry_run:
+        Renderer(state.json_output, state.show_sensitive).details(
+            "Operation plan", fields, response=plan
+        )
+        return
+    confirm_details(state, "Operation plan", fields, "Confirm this operation?", yes)
+    modified = call(state, "ModifyCompShareShareBandwidth", params)
+    Renderer(state.json_output, state.show_sensitive).details(
+        "Operation completed",
+        [("BANDWIDTH ID", bandwidth_id), ("BANDWIDTH", f"{bandwidth} Mbps")],
+        response={"price": quote, "modified": modified},
+    )
+
+
+@app.command("delete", help="Delete dedicated bandwidth after quoting the refund.")
+def delete(
+    ctx: typer.Context,
+    bandwidth_id: str = typer.Argument(..., help="Dedicated bandwidth ID."),
+    region: str = typer.Option(..., "--region", help="Region for this request."),
+    zone: str = typer.Option(..., "--zone", help="Availability zone."),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        help="Quote and show the request without deleting bandwidth.",
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    state = runtime(ctx)
+    params = _request(ctx, region, zone, {"ShareBandwidthId": bandwidth_id})
+    quote = call(state, "GetCompShareShareBandwidthRefundPrice", params)
+    plan = {"dry_run": dry_run, "request": params, "refund": quote}
+    fields = [
+        ("BANDWIDTH ID", bandwidth_id),
+        ("ZONE", zone),
+        ("REFUND", _cny(quote.get("RefundPrice"), signed=True)),
+        ("ACTION", tr("Migrate bound EIPs to shared bandwidth, then delete")),
+    ]
+    if dry_run:
+        Renderer(state.json_output, state.show_sensitive).details(
+            "Operation plan", fields, response=plan
+        )
+        return
+    confirm_details(state, "Operation plan", fields, "Confirm this operation?", yes)
+    deleted = call(state, "DeleteCompShareShareBandwidth", params)
+    Renderer(state.json_output, state.show_sensitive).details(
+        "Operation completed",
+        [
+            ("BANDWIDTH ID", bandwidth_id),
+            ("MIGRATED EIPS", deleted.get("MigratedEIPCount", 0)),
+        ],
+        response={"refund": quote, "deleted": deleted},
+    )
+
+
+@app.command("switch", help="Switch instance EIPs between dedicated and shared bandwidth.")
+def switch(
+    ctx: typer.Context,
+    instances: List[str] = typer.Argument(..., help="Instance IDs."),
+    target: str = typer.Option(..., "--to", help="Target bandwidth: dedicated or shared."),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation."),
+) -> None:
+    state = runtime(ctx)
+    target_scope, target_name = _target_scope(target)
+    requested = list(dict.fromkeys(instances))
+    locations, missing = locate_instances(state, requested)
+    confirm_details(
+        state,
+        "Operation plan",
+        [("INSTANCE", requested), ("TARGET", tr(target_name))],
+        "Confirm this operation?",
+        yes,
+    )
+
+    results: List[Dict[str, Any]] = [
+        {
+            "UHostId": instance,
+            "Success": False,
+            "Message": tr("Instance {instance} was not found.", instance=instance),
+        }
+        for instance in missing
+    ]
+    groups: Dict[Tuple[str, str], List[str]] = {}
+    for instance in requested:
+        location = locations.get(instance)
+        if location is not None:
+            groups.setdefault((location[0], location[1]), []).append(instance)
+
+    for (region, zone), ids in groups.items():
+        response, error = call_captured(
+            state,
+            "SwitchCompShareEIPShareBandwidth",
+            _request(
+                ctx,
+                region,
+                zone,
+                {"UHostIds": ids, "TargetScope": target_scope},
+            ),
+        )
+        if error:
+            results.extend(
+                {
+                    "UHostId": instance,
+                    "Region": region,
+                    "Zone": zone,
+                    "Success": False,
+                    "Message": error.get("message"),
+                }
+                for instance in ids
+            )
+            continue
+        returned = {
+            str(item.get("UHostId")): item for item in (response or {}).get("Results") or []
+        }
+        for instance in ids:
+            item = returned.get(instance) or {
+                "UHostId": instance,
+                "Success": False,
+                "Message": tr(
+                    "The API returned no result for instance {instance}.", instance=instance
+                ),
+            }
+            results.append({**item, "Region": region, "Zone": zone})
+
+    failed = [item for item in results if not item.get("Success")]
+    payload: Dict[str, Any] = {"Results": results}
+    if failed:
+        payload.update(
+            {
+                "ok": False,
+                "error": {
+                    "code": "partial_failure",
+                    "message": tr("Some bandwidth switches failed."),
+                },
+            }
+        )
+    Renderer(state.json_output, state.show_sensitive).data(
+        payload,
+        rows=results,
+        columns=(
+            ("UHostId", "INSTANCE"),
+            ("Zone", "ZONE"),
+            ("Success", "SUCCESS"),
+            ("CurrentScope", "BANDWIDTH SCOPE"),
+            ("Message", "MESSAGE"),
+        ),
+    )
+    if failed:
+        raise typer.Exit(1)