hcs-cli 0.1.317__py3-none-any.whl → 0.1.319__py3-none-any.whl

hcs_cli/cmds/inventory/assign.py

@@ -13,47 +13,91 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import json
-import sys
 import uuid
 
 import click
 import hcs_core.sglib.cli_options as cli
 
-from hcs_cli.service import auth, inventory, portal
+from hcs_cli.service import admin, auth, inventory, lcm, portal
 from hcs_cli.support.param_util import parse_vm_path
 
 
 @click.command()
 @cli.org_id
-@click.option(
-    "--file",
-    "-f",
-    type=click.File("rt"),
-    default=sys.stdin,
-    help="Specify the template file name. If not specified, STDIN will be used.",
-)
-@click.option("--vm", type=str, required=False)
-def assign(org: str, file, vm: str):
+@click.argument("vm_path", type=str, required=False)
+def assign(org: str, vm_path: str):
     """Assign user to VM"""
     org_id = cli.get_org_id(org)
+    template_id, vm_id = parse_vm_path(vm_path)
 
-    with file:
-        data = file.read()
-
-    try:
-        payload = json.loads(data)
-    except Exception as e:
-        msg = "Invalid payload: " + str(e)
-        return msg, 1
-
-    if vm:
-        template, vm_id = parse_vm_path(vm)
-        payload["templateIds"] = [template]
-        payload["vmId"] = vm_id
+    template = admin.template.get(template_id, org_id)
+    if template:
+        edge_id = template["edgeDeploymentId"]
+    else:
+        # try with lcm
+        template = lcm.template.get(template_id, org_id)
+        edge_id = template["edgeGateway"]["id"]
+    if not template:
+        return "Template not found: " + template_id, 1
+    payload = {
+        "id": "dspec1",
+        "userId": "user1",
+        "clientId": "client-1",
+        "entitlementId": "entitlement-1",
+        "templateIds": [template_id],
+        "allocationPolicy": "ANY",
+        "sessionType": "DESKTOP",
+        "username": "user1",
+        "userPrincipalName": "aduser1@vmwhorizon.com",
+        "userSid": "S-1-5-21-2502306595",
+        "orgId": org_id,
+        "location": template["location"],
+        "vmId": vm_id,
+        "templateType": template["templateType"],
+        "resume": True,
+        "clientSessionId": "client-uuid-1",
+    }
+    # print(json.dumps(payload, indent=4))
+    inventory.assignV2(payload)
 
-    payload["orgId"] = org_id
-    return inventory.assign(payload)
+    # payload_manual_session = {
+    #     "templateId": "string",
+    #     "vmId": "string",
+    #     "userId": "string",
+    #     "agentSessionGuid": "string",
+    #     "agentSessionId": "string",
+    #     "agentStaticSessionGuid": "string",
+    #     "sessionType": "DESKTOP",
+    #     "templateType": "FLOATING",
+    #     "clientId": "string",
+    #     "sessionStatus": "string",
+    #     "lastAssignedTime": "2025-12-16T20:56:08.988Z",
+    #     "lastLoginTime": "2025-12-16T20:56:08.988Z",
+    #     "lastStatusUpdateTime": "2025-12-16T20:56:08.988Z",
+    #     "username": "string",
+    #     "userPrincipalName": "string",
+    #     "userSid": "string",
+    #     "entitlementId": "string",
+    #     "orgId": "string",
+    #     "location": "string",
+    #     "clientSessionId": "UUID string",
+    #     "agentErrorCode": "AGENT_ERR_FAILURE",
+    #     "staticCloudSessionId": "UUID string",
+    #     "hibernated": true,
+    #     "id": 0,
+    #     "dspecId": "string"
+    # }
+    payload_update = {
+        "id": "dspec1",
+        "agentSessionGuid": "agent-session-guid-1",
+        "agentSessionId": "agent-session-1",
+        "agentStaticSessionGuid": "agent-static-session-guid-1",
+        "sessionStatus": "string",
+        "vmId": vm_id,
+        "edgeId": edge_id,
+        "agentErrorCode": "",
+    }
+    return inventory.update_session(org_id=org_id, template_id=template_id, payload=payload_update)
 
 
 @click.command()
@@ -84,7 +128,7 @@ def bulk_assign(org: str, pool_group: str, pool: str, num_users: int):
 
     num_users = int(num_users)
     if num_users > len(users["users"]):
-        print(f'max available users in AD = {len(users["users"])}, set -n less than {len(users["users"])}')
+        print(f"max available users in AD = {len(users['users'])}, set -n less than {len(users['users'])}")
         return
     fu = users["users"][:num_users]
     dspecs = []

hcs_cli/cmds/inventory/deassign.py

@@ -19,29 +19,46 @@ import sys
 import click
 import hcs_core.sglib.cli_options as cli
 
-from hcs_cli.service import inventory
+from hcs_cli.service import admin, inventory, lcm
+from hcs_cli.support.param_util import parse_vm_path
 
 
 @click.command()
 @cli.org_id
-@click.option(
-    "--file",
-    "-f",
-    type=click.File("rt"),
-    default=sys.stdin,
-    help="Specify the template file name. If not specified, STDIN will be used.",
-)
-def deassign(org: str, file):
+@click.argument("vm_path", type=str, required=False)
+def deassign(org: str, vm_path: str):
     """Assign user to VM"""
     org_id = cli.get_org_id(org)
-    with file:
-        data = file.read()
+    template_id, vm_id = parse_vm_path(vm_path)
+    sessions = inventory.sessions(template_id, vm_id, cli.get_org_id(org))
 
-    try:
-        payload = json.loads(data)
-    except Exception as e:
-        msg = "Invalid payload: " + str(e)
-        return msg, 1
+    template = admin.template.get(template_id, cli.get_org_id(org))
+    if template:
+        edge_deployment_id = template["edgeDeploymentId"]
+    else:
+        # try with lcm
+        template = lcm.template.get(template_id, cli.get_org_id(org))
+        if not template:
+            return "Template not found: " + template_id, 1
+        edge_deployment_id = template["edgeGateway"]["id"]
 
-    payload["orgId"] = org_id
-    return inventory.deassign(payload)
+    all_ret = []
+    for session in sessions:
+        payload = {
+            "vmHubName": template["hdc"]["vmHub"]["name"],
+            "edgeDeploymentId": edge_deployment_id,
+            "vmId": vm_id,
+            "entitlementId": session.get("entitlementId"),
+            "agentSessionGuid": session.get("agentSessionGuid"),
+            "agentSessionId": session.get("agentSessionId"),
+            "agentStaticSessionGuid": session.get("agentStaticSessionGuid"),
+            "id": session.get("dspecId"),
+            "userId": session.get("userId"),
+            "type": "CONNECTION_ENDED",
+        }
+        ret = inventory.deassign(template_id=template_id, org_id=org_id, payload=payload)
+        all_ret.append(ret)
+
+    if len(all_ret) == 1:
+        return all_ret[0]
+    return all_ret

hcs_cli/cmds/inventory/logoff.py

@@ -16,17 +16,95 @@ limitations under the License.
 import click
 import hcs_core.sglib.cli_options as cli
 
-from hcs_cli.service import inventory
+from hcs_cli.service import admin, inventory, lcm
 from hcs_cli.support.param_util import parse_vm_path
 
 
 @click.command()
 @cli.org_id
-@click.argument("vm_path", type=str, required=True)
+@click.argument("vm_path", type=str, required=False)
 def logoff(org: str, vm_path: str):
-    """Log off an user"""
-    template, vm = parse_vm_path(vm_path)
-    ret = inventory.logoff(template, vm, cli.get_org_id(org))
-    if ret:
-        return ret
-    return ret, 1
+    """Logoff all sessions on the vm.
+
+    Example: hcs inventory logoff template_id/vm_id
+    """
+
+    org_id = cli.get_org_id(org)
+    template_id, vm_id = parse_vm_path(vm_path)
+    sessions = inventory.sessions(template_id, vm_id, cli.get_org_id(org))
+    if not sessions:
+        return
+    # [
+    #     {
+    #         "templateId": null,
+    #         "vmId": "expool000",
+    #         "userId": "c12b884b-c813-4f73-81f5-df2052de9bc6",
+    #         "agentSessionGuid": null,
+    #         "agentSessionId": null,
+    #         "agentStaticSessionGuid": null,
+    #         "sessionType": "DESKTOP",
+    #         "templateType": "FLOATING",
+    #         "clientId": null,
+    #         "sessionStatus": "ASSIGNED",
+    #         "lastAssignedTime": "2025-12-16T18:55:45.078+00:00",
+    #         "lastLoginTime": null,
+    #         "lastStatusUpdateTime": "2025-12-16T18:55:45.078+00:00",
+    #         "username": "u1ad1",
+    #         "userPrincipalName": "u1ad1@horizonv2dev2.local",
+    #         "userSid": "S-1-5-21-1840667356-2516272024-4034330832-1104",
+    #         "releaseSessionOnDeassign": false,
+    #         "entitlementId": "6941a2bfe79a1b9cef167ad2",
+    #         "orgId": "7c4f9042-6119-45b6-93f5-24f1a80e2c62",
+    #         "location": null,
+    #         "clientSessionId": null,
+    #         "agentErrorCode": "",
+    #         "staticCloudSessionId": "dc907d57-85d8-478e-9d0c-028c1acd87f2",
+    #         "hibernated": null,
+    #         "id": null,
+    #         "dspecId": "5722ff4a-7e75-4248-89e9-741d8a7ae91c"
+    #     }
+    # ]
+
+    template = admin.template.get(template_id, cli.get_org_id(org))
+    if template:
+        edge_deployment_id = template["edgeDeploymentId"]
+    else:
+        # try with lcm
+        template = lcm.template.get(template_id, cli.get_org_id(org))
+        if not template:
+            return "Template not found: " + template_id, 1
+        edge_deployment_id = template["edgeGateway"]["id"]
+
+    all_ret = []
+    for session in sessions:
+        logoff_payload_v1 = {
+            "edgeDeploymentId": edge_deployment_id,
+            "vmId": vm_id,
+            "userId": session.get("userId"),
+            "entitlementId": session.get("entitlementId"),
+            "vmHubName": template["hdc"]["vmHub"]["name"],
+            "sessionType": session.get("sessionType"),
+        }
+        ret1 = inventory.logoff(template_id=template_id, org_id=org_id, payload=logoff_payload_v1)
+        # print("PAYLOADv1: ", logoff_payload_v1)
+        # print("RETv1: ", ret1)
+        all_ret.append(ret1)
+
+        logoff_payload_v2 = [
+            {
+                "agentSessionGuid": session.get("agentSessionGuid"),
+                "userId": session.get("userId"),
+                "sessionType": session.get("sessionType"),
+                "vmHubName": template["hdc"]["vmHub"]["name"],
+                "edgeDeploymentId": edge_deployment_id,
+                "vmId": vm_id,
+                "dspecId": session.get("dspecId"),
+                "dtemplateId": template_id,
+            }
+        ]
+        ret2 = inventory.logoffV2(org_id=org_id, payload=logoff_payload_v2)
+        # print("PAYLOADv2: ", logoff_payload_v2)
+        # print("RETv2: ", ret2)
+        all_ret.append(ret2)
+
+    return all_ret

hcs_cli/cmds/inventory/session.py

@@ -16,7 +16,7 @@ limitations under the License.
 import click
 import hcs_core.sglib.cli_options as cli
 
-from hcs_cli.service import inventory
+from hcs_cli.service import admin, inventory
 from hcs_cli.support.param_util import parse_vm_path
 
 
@@ -27,7 +27,7 @@ def session():
 
 @session.command()
 @cli.org_id
-@click.argument("vm_path", type=str, required=True)
+@click.argument("vm_path", type=str, required=False)
 def list(org: str, vm_path: str):
     """List sessions"""
     template, vm = parse_vm_path(vm_path)

hcs_cli/cmds/scm/operator.py

@@ -60,8 +60,8 @@ def _print_error(text: str):
 
 def _print_human_readable_log(d: TaskModel):
     ret = d.log
-    time_started = ret.time_started
-    time_completed = ret.time_completed
+    time_started = ret.timeStarted
+    time_completed = ret.timeCompleted
 
     if time_completed:
         delta = timedelta(milliseconds=time_completed - time_started)

hcs_cli/cmds/scm/plan.py

@@ -16,11 +16,13 @@ limitations under the License.
 import json
 import re
 import sys
+from datetime import datetime, timedelta
 from os import path
 
 import click
 import hcs_core.sglib.cli_options as cli
-from hcs_core.ctxp import data_util, recent
+import yumako
+from hcs_core.ctxp import data_util, recent, util
 from hcs_core.sglib.client_util import wait_for_res_status
 
 import hcs_cli.service.scm as scm
@@ -33,6 +35,98 @@ def plan():
     pass
 
 
+def _get_next_slot_name():
+    """
+    Get the current and next half-hour aligned slot names and time delta based on current UTC time.
+
+    Slots are half-hour aligned (HH:00 or HH:30).
+
+    Returns:
+        tuple: (current_slot_name, next_slot_name, timedelta_to_next_slot)
+               where slot names are in format 'weekday/HH:MM' (e.g., 'monday/18:00')
+               and timedelta_to_next_slot is a timedelta object
+    """
+    current_time_utc = datetime.utcnow()
+
+    # Weekday names mapping (0=Monday, 6=Sunday in Python's weekday())
+    weekday_names = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
+
+    # Get current half-hour aligned slot (round down)
+    current_minute = current_time_utc.minute
+    if current_minute < 30:
+        # Current slot is this hour:00
+        current_slot_time = current_time_utc.replace(minute=0, second=0, microsecond=0)
+    else:
+        # Current slot is this hour:30
+        current_slot_time = current_time_utc.replace(minute=30, second=0, microsecond=0)
+
+    current_weekday_name = weekday_names[current_slot_time.weekday()]
+    current_time_str = current_slot_time.strftime("%H:%M")
+    current_slot_name = f"{current_weekday_name}/{current_time_str}"
+
+    # Get next half-hour aligned slot
+    if current_minute < 30:
+        # Next slot is this hour:30
+        next_time = current_time_utc.replace(minute=30, second=0, microsecond=0)
+    else:
+        # Next slot is next hour:00
+        next_time = current_time_utc + timedelta(hours=1)
+        next_time = next_time.replace(minute=0, second=0, microsecond=0)
+
+    next_weekday_name = weekday_names[next_time.weekday()]
+    next_time_str = next_time.strftime("%H:%M")
+    next_slot_name = f"{next_weekday_name}/{next_time_str}"
+
+    timedelta_to_next = next_time - current_time_utc
+
+    return current_slot_name, next_slot_name, timedelta_to_next
+
+
+def _format_scm_plan_task_table(data):
+    fields_mapping = {
+        "location": "Location",
+        "_slot": "Slot",
+        "_timeCreatedStale": "Time Created",
+    }
+
+    current_slot_name, next_slot_name, timedelta_to_next = _get_next_slot_name()
+    time_str_to_next = yumako.time.display(timedelta_to_next.total_seconds())
+
+    for d in data:
+        d["_timeCreatedStale"] = yumako.time.stale(d["timeCreated"] / 1000)
+        meta = d["meta"]
+        input = d["input"]
+        my_slot_name = meta["scm_plan_day"] + "/" + meta["scm_plan_slot"]
+        d["_slot"] = my_slot_name
+
+        if d["worker"] == "com.vmware.horizon.sg.scm.task.CapacityOptimization":
+            d["_idealCapacity"] = input["idealCapacity"]
+            d["_forecastCapacity"] = input["forecastCapacity"]
+            d["_taskKey"] = d["key"]
+
+            if my_slot_name == next_slot_name:
+                d["_nextExecution"] = click.style(f"In {time_str_to_next}", fg="bright_blue")
+            else:
+                d["_nextExecution"] = ""
+            fields_mapping["_nextExecution"] = "Next"
+
+            if my_slot_name == current_slot_name:
+                # d['_lastExecutedStale'] = 'TODO'
+                # d['_lastExecutionStatus'] = 'TODO'
+                # fields_mapping['_lastExecutedStale'] = 'Executed'
+                # fields_mapping['_lastExecutionStatus'] = 'Status'
+                pass
+
+            fields_mapping["_idealCapacity"] = "Ideal"
+            fields_mapping["_forecastCapacity"] = "Forecast"
+            fields_mapping["_taskKey"] = "Task Key"
+        else:
+            # TODO other worker types
+            pass
+
+    return util.format_table(data, fields_mapping)
+
+
 @plan.command
 @click.option("--template", help="Filter plan by template.")
 @click.option("--task", help="Filter plan by task class name.")
@@ -99,7 +193,7 @@ def delete(org: str, name: str, confirm: bool, **kwargs):
 
 @plan.command
 @cli.org_id
-@cli.limit
+@cli.limit(default=336)
 @click.option("--day", required=False, help="Search by day-identifier. Example: Monday")
 @click.option("--time", required=False, help="Search by time. Example: 13:30")
 @click.option("--slot", required=False, help="Search by time slot. Example: Mon/13:30")
@@ -111,6 +205,7 @@ def delete(org: str, name: str, confirm: bool, **kwargs):
     help="Search by task state, as comma-separated values. E.g. 'init,running,success,error', or 'all'.",
 )
 @click.argument("name", required=False)
+@cli.formatter(_format_scm_plan_task_table)
 def tasks(org: str, limit: int, day: str, time: str, slot: str, name: str, state: str, **kwargs):
     """Get tasks of a named calendar plan."""
     org = cli.get_org_id(org)
@@ -134,6 +229,40 @@ def tasks(org: str, limit: int, day: str, time: str, slot: str, name: str, state
     ret = scm.plan.tasks(org_id=org, id=name, limit=limit, day=day, slot=time, states=state, **kwargs)
     if ret is None:
         return "", 1
+
+    # sort tasks by slot.
+    for t in ret:
+        meta = t["meta"]
+        d = meta["scm_plan_day"]
+        if d == "sunday":
+            d = "0"
+        elif d == "monday":
+            d = "1"
+        elif d == "tuesday":
+            d = "2"
+        elif d == "wednesday":
+            d = "3"
+        elif d == "thursday":
+            d = "4"
+        elif d == "friday":
+            d = "5"
+        elif d == "saturday":
+            d = "6"
+        else:
+            raise ValueError("Invalid day name in task meta: " + d)
+        t["_slot"] = d + "/" + meta["scm_plan_slot"]
+    ret = sorted(ret, key=lambda x: x["_slot"])
+    for t in ret:
+        del t["_slot"]
+
+    # identify the current task result
+    # current_slot_name, next_slot_name, timedelta_to_next = _get_next_slot_name()
+    # for t in ret:
+    #     meta = t['meta']
+    #     my_slot_name = meta['scm_plan_day'] + '/' + meta['scm_plan_slot']
+    #     if current_slot_name == my_slot_name:
+    #         break
+
     return ret
 
 
@@ -343,7 +472,6 @@ def run(org: str, name: str, slot: str, config: str, wait: str, **kwargs):
 
 
 def _wait_for_task(org_id: str, name: str, task_key: str, timeout: str):
-
     return wait_for_res_status(
         resource_name=name + "/" + task_key,
         fn_get=lambda: scm.plan.get_task(org_id, name, task_key),

hcs_cli/cmds/task.py

@@ -13,8 +13,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-import json
-
 import click
 import hcs_core.sglib.cli_options as cli
 import yumako
@@ -29,9 +27,9 @@ def _format_task_table(data):
         schedule = d.get("schedule")
         if schedule:
             if schedule.get("intervalMs"):
-                recurring = f'Every {yumako.time.display(schedule["intervalMs"] / 1000)}'
+                recurring = f"Every {yumako.time.display(schedule['intervalMs'] / 1000)}"
             elif schedule.get("cronExpression"):
-                recurring = f'{schedule["cronExpression"]}'
+                recurring = f"{schedule['cronExpression']}"
             else:
                 recurring = "<No>"
         else:

hcs_cli/cmds/template/expand.py

@@ -0,0 +1,65 @@
+"""
+Copyright 2023-2023 VMware Inc.
+SPDX-License-Identifier: Apache-2.0
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import click
+import hcs_core.sglib.cli_options as cli
+import hcs_core.util.duration as duration
+from hcs_core.ctxp import recent
+
+import hcs_cli.service.admin as admin
+
+
+@click.command(hidden=True)
+@click.option(
+    "--number",
+    "-n",
+    type=int,
+    required=False,
+    default=1,
+    help="Number of VMs to expand. Use negative number to shrink.",
+)
+@click.argument("template_id", type=str, required=False)
+@cli.org_id
+@cli.wait
+def expand(number: int, template_id: str, org: str, wait: str, **kwargs):
+    """Update an existing template"""
+
+    org_id = cli.get_org_id(org)
+
+    template_id = recent.require("template", template_id)
+    template = admin.template.get(template_id, org_id)
+
+    if not template:
+        return "Template not found: " + template_id
+
+    spare_policy = template.get("sparePolicy", {})
+    patch = {
+        "sparePolicy": {
+            "min": spare_policy.get("min", 0) + number,
+            "max": spare_policy.get("max", 0) + number,
+            "limit": spare_policy.get("limit", 0) + number,
+        }
+    }
+    if patch["sparePolicy"]["min"] < 0:
+        patch["sparePolicy"]["min"] = 0
+    if patch["sparePolicy"]["max"] < 0:
+        patch["sparePolicy"]["max"] = 0
+    if patch["sparePolicy"]["limit"] < 0:
+        patch["sparePolicy"]["limit"] = 0
+
+    ret = admin.template.update(template_id, org_id, patch)
+    if wait != "0":
+        ret = admin.template.wait_for_ready(template_id, org_id, duration.to_seconds(wait))
+    return ret

hcs_cli/cmds/template/list_usage.py

@@ -111,8 +111,8 @@ def list_usage(org: str, **kwargs):
             "addedVmHours": summary.get("addedVmHours"),
             "offloadVmHours": summary.get("offloadVmHours"),
             "reducedVmHours": summary.get("reducedVmHours"),
-            "historyVmUtilizationPercent": f'{summary.get("historyVmUtilizationPercent", 0)}%',
-            "predictionVmUtilizationPercent": f'{summary.get("predictionVmUtilizationPercent", 0)}%',
+            "historyVmUtilizationPercent": f"{summary.get('historyVmUtilizationPercent', 0)}%",
+            "predictionVmUtilizationPercent": f"{summary.get('predictionVmUtilizationPercent', 0)}%",
         }
 
         ret2.append(item)

hcs_cli/cmds/template/usage.py

@@ -13,6 +13,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+import json
 import os
 import tempfile
 import time
@@ -32,17 +33,28 @@ def _timestamp_to_date(timestamp: int):
 
 
 @click.command(hidden=True)
+@click.option(
+    "--local-plan-file",
+    type=str,
+    required=False,
+    help="Instead of reading from API, read from local file for the template usage data. Debug only.",
+)
 @click.argument("id", type=str, required=False)
 @cli.org_id
-def usage(id: str, org: str, **kwargs):
+def usage(id: str, org: str, local_plan_file: str = None, **kwargs):
     """Show usage visualization"""
 
     org_id = cli.get_org_id(org)
     id = recent.require("template", id)
 
-    usage = scm.template_usage(org_id, id)
-    if not usage:
-        return "No usage data found", 1
+    if local_plan_file:
+        with open(local_plan_file, "r") as f:
+            plan_data = json.load(f)
+            usage = plan_data["meta"]
+    else:
+        usage = scm.template_usage(org_id, id)
+        if not usage:
+            return "No usage data found", 1
 
     x_axis = []
     consumed_capacity = []
@@ -61,8 +73,9 @@ def usage(id: str, org: str, **kwargs):
         x_axis.append(_timestamp_to_date(t))
         max_capacity = history["maxCapacity"][i]
         min_free = history["minFree"][i]
-        consumed_capacity.append(max_capacity - min_free)
-        spare_capacity.append(min_free)
+        # consumed_capacity.append(max_capacity - min_free)
+        consumed_capacity.append(history["poweredOnAssignedVms"][i])
+        spare_capacity.append(max_capacity - consumed_capacity[-1])
         no_spare_error.append(history["noSpare"][i])
 
     start_timestamp = prediction["startTimestamp"]
@@ -72,7 +85,7 @@ def usage(id: str, org: str, **kwargs):
         max_capacity = prediction["maxCapacity"][i]
         min_free = prediction["minFree"][i]
         ideal_capacity = prediction["idealCapacity"][i]
-        consumed_capacity_predicated.append(ideal_capacity - min_free)
+        consumed_capacity_predicated.append(ideal_capacity)
         spare_capacity_predicated.append(min_free)
         optimized_capacity.append(ideal_capacity)
         no_spare_error_predicated.append(prediction["noSpare"][i])

hcs_cli/cmds/vm/list.py

@@ -129,7 +129,6 @@ def list_vms(
 
     vms = []
     if template_id and template_id.lower() == "all":
-
         cloud = _to_lower(cloud)
 
         def to_search_condition(values):