@dao-style/biz 0.6.0 → 0.7.0

package/dist/components/gpu/src/components/GpuAdvancedForm.vue2.mjs

@@ -0,0 +1,153 @@
+import { defineComponent, ref, computed } from "vue";
+import * as yup from "yup";
+import { useI18n } from "vue-i18n";
+import { useVModel } from "../../../../node_modules/@vueuse/core/index.mjs";
+import { DaoFormItemValidate } from "@dao-style/extend";
+import { useFieldValue } from "vee-validate";
+import { gpuAdvancedFormProps, getPriorityOpts, nvidiaVgpuCoreResource } from "../../props.mjs";
+import { nvidiaVgpuNodeScheduleKey, nvidiaVgpuGpuScheduleKey, nvidiaVgpuModelKey, nvidiaVgpuDevicesKey, nvidiaVgpuPriorityKey } from "../../types.mjs";
+import DaoAssignGpuDevicesList from "./AssignGpuDevicesList.vue.mjs";
+import { isNvidiaVgpu, getGPUResourceValue, isNvidiaGpu } from "../../utils.mjs";
+import { useSetFieldValue } from "../../../../utils/useSetFieldValue.mjs";
+const _sfc_main = defineComponent({
+  name: "DaoGpuAdvancedForm",
+  components: {
+    DaoFormItemValidate,
+    DaoAssignGpuDevicesList
+  },
+  props: gpuAdvancedFormProps,
+  emits: [
+    "update:openNvidiaVgpuModel",
+    "update:openNvidiaVgpuSchedulePolicy",
+    "update:openNvidiaAssignGpu"
+  ],
+  setup(props, { emit }) {
+    const openNvidiaVgpuModelRef = useVModel(props, "openNvidiaVgpuModel", emit);
+    const openNvidiaVgpuSchedulePolicyRef = useVModel(props, "openNvidiaVgpuSchedulePolicy", emit);
+    const openNvidiaAssignGpuRef = useVModel(props, "openNvidiaAssignGpu", emit);
+    const i18nInstance = useI18n();
+    const gpuCallValue = ref("local");
+    const priorityOpts = getPriorityOpts(i18nInstance);
+    const nodeScheduleModel = useFieldValue(nvidiaVgpuNodeScheduleKey);
+    const gpuScheduleModel = useFieldValue(nvidiaVgpuGpuScheduleKey);
+    const scheduleOps = [
+      {
+        label: "Binpack",
+        value: "binpack"
+      },
+      {
+        label: "Spread",
+        value: "spread"
+      }
+    ];
+    const nodeScheduleHelper = computed(() => nodeScheduleModel.value && nodeScheduleModel.value === "spread" ? i18nInstance.t("biz.components.Gpu.baseNodeSchedule.spreadHelper") : i18nInstance.t("biz.components.Gpu.baseNodeSchedule.binpackHelper"));
+    const gpuScheduleHelper = computed(() => gpuScheduleModel.value && gpuScheduleModel.value === "spread" ? i18nInstance.t("biz.components.Gpu.baseGpuSchedule.spreadHelper") : i18nInstance.t("biz.components.Gpu.baseGpuSchedule.binpackHelper"));
+    const setModelValue = useSetFieldValue(nvidiaVgpuModelKey);
+    const setDevicesValue = useSetFieldValue(nvidiaVgpuDevicesKey);
+    const setGpuScheduleValue = useSetFieldValue(nvidiaVgpuGpuScheduleKey);
+    const setNodeScheduleValue = useSetFieldValue(nvidiaVgpuNodeScheduleKey);
+    const nvidiaVgpuModelValue = useFieldValue(nvidiaVgpuModelKey);
+    const nvidiaVgpuDevicesValue = useFieldValue(nvidiaVgpuDevicesKey);
+    const handleNvidiaVgpuSchedulePolicyChange = (open) => {
+      if (open) {
+        setGpuScheduleValue("binpack");
+        setNodeScheduleValue("spread");
+      }
+    };
+    const isNvidiaVgpuType = computed(() => {
+      var _a;
+      return isNvidiaVgpu(((_a = props.quota) == null ? void 0 : _a.type) ?? "");
+    });
+    const showAdvancedConfig = computed(() => isNvidiaVgpuType.value && (props.enableNvidiaVgpuModel || props.enableNvidiaVgpuDevices || props.enableNvidiaVgpuPriority || props.enableNvidiaVgpuSchedulePolicy));
+    const assignTypes = computed(() => {
+      const types = [];
+      if (props.enableNvidiaVgpuModel) {
+        types.push({
+          value: "assignModel",
+          label: i18nInstance.t("biz.components.Gpu.assignGpu.assignModel")
+        });
+      }
+      if (props.enableNvidiaVgpuDevices) {
+        types.push({
+          value: "assignDevice",
+          label: i18nInstance.t("biz.components.Gpu.assignGpu.assignCard")
+        });
+      }
+      return types;
+    });
+    const getInitialAssignGpuType = () => {
+      var _a, _b, _c;
+      const model = nvidiaVgpuModelValue.value ?? ((_a = props.quota) == null ? void 0 : _a[nvidiaVgpuModelKey]);
+      const devices = nvidiaVgpuDevicesValue.value ?? ((_b = props.quota) == null ? void 0 : _b[nvidiaVgpuDevicesKey]);
+      if (model && props.enableNvidiaVgpuModel) {
+        return "assignModel";
+      }
+      if ((devices == null ? void 0 : devices.length) && props.enableNvidiaVgpuDevices) {
+        return "assignDevice";
+      }
+      return ((_c = assignTypes.value[0]) == null ? void 0 : _c.value) ?? "assignModel";
+    };
+    const assignGpuType = ref(getInitialAssignGpuType());
+    const displayNvidiaGpuModels = computed(() => {
+      var _a;
+      const assignedModel = nvidiaVgpuModelValue.value ?? ((_a = props.quota) == null ? void 0 : _a[nvidiaVgpuModelKey]);
+      const models = props.nvidiaGpuModels ?? [];
+      const readonly = props.assignGpuDisabled || props.isSide;
+      if (!readonly || !assignedModel || models.includes(assignedModel)) {
+        return models;
+      }
+      return [...models, assignedModel];
+    });
+    const handleAssignGpuTypeChange = (value) => {
+      var _a;
+      if (value === "assignModel") {
+        setDevicesValue([]);
+        if (props.quota) {
+          setModelValue((_a = props.nvidiaGpuModels) == null ? void 0 : _a[0]);
+        }
+      } else {
+        setModelValue(void 0);
+      }
+    };
+    const nvidiaVgpuCore = computed(() => {
+      var _a;
+      if (isNvidiaVgpuType.value) {
+        const coreStr = getGPUResourceValue((_a = props.quota) == null ? void 0 : _a.resources, nvidiaVgpuCoreResource);
+        return coreStr ? Number(coreStr) : void 0;
+      }
+      return void 0;
+    });
+    const yupDevicesSchema = computed(() => yup.array().of(
+      yup.string().required()
+    ).min(1, i18nInstance.t("biz.components.Gpu.assignGpu.validate.assignCardRequired")).test("defaultCore", i18nInstance.t("biz.components.Gpu.assignGpu.validate.coreFirst"), () => !(nvidiaVgpuCore.value === void 0 || nvidiaVgpuCore.value === 0)).max(nvidiaVgpuCore.value ?? 0, i18nInstance.t("biz.components.Gpu.assignGpu.validate.assignModelMax", { max: nvidiaVgpuCore.value ?? 0 })));
+    return {
+      gpuCallValue,
+      priorityOpts,
+      openNvidiaVgpuModelRef,
+      nvidiaVgpuModelKey,
+      nvidiaVgpuPriorityKey,
+      isNvidiaVgpuType,
+      isNvidiaGpu,
+      showAdvancedConfig,
+      scheduleOps,
+      openNvidiaVgpuSchedulePolicyRef,
+      handleNvidiaVgpuSchedulePolicyChange,
+      nvidiaVgpuGpuScheduleKey,
+      nvidiaVgpuNodeScheduleKey,
+      nodeScheduleHelper,
+      gpuScheduleHelper,
+      nvidiaVgpuCore,
+      assignTypes,
+      openNvidiaAssignGpuRef,
+      handleAssignGpuTypeChange,
+      assignGpuType,
+      displayNvidiaGpuModels,
+      nvidiaVgpuDevicesKey,
+      yupDevicesSchema,
+      yup
+    };
+  }
+});
+export {
+  _sfc_main as default
+};

package/dist/components/gpu/src/{GpuFormDynamicItem.vue.d.ts → components/GpuFormDynamicItem.vue.d.ts}

@@ -1,5 +1,5 @@
 import type { MultiRowEditorColumn } from '@dao-style/extend';
-import { ResourceRange } from '../types';
+import type { ResourceRange } from '../../types';
 interface dynamicQuota {
     spec?: string;
     count?: number;
@@ -22,7 +22,7 @@ declare const _default: import("vue").DefineComponent<{
         default: boolean;
     };
     displayResource: {
-        type: import("vue").PropType<import("../types").GPUResourceSetting[]>;
+        type: import("vue").PropType<import("../../types").GPUResourceSetting[]>;
         required: boolean;
         default: () => never[];
     };
@@ -563,7 +563,7 @@ declare const _default: import("vue").DefineComponent<{
         default: boolean;
     };
     displayResource: {
-        type: import("vue").PropType<import("../types").GPUResourceSetting[]>;
+        type: import("vue").PropType<import("../../types").GPUResourceSetting[]>;
         required: boolean;
         default: () => never[];
     };
@@ -584,6 +584,6 @@ declare const _default: import("vue").DefineComponent<{
     isSide: boolean;
     availableQuotaItem: Record<string, string | number | undefined> | undefined;
     usedQuotaItem: Record<string, string | number | undefined> | undefined;
-    displayResource: import("../types").GPUResourceSetting[];
+    displayResource: import("../../types").GPUResourceSetting[];
 }>;
 export default _default;

package/dist/components/gpu/src/{GpuFormDynamicItem.vue.js → components/GpuFormDynamicItem.vue.js}

@@ -1,7 +1,7 @@
 "use strict";
 const GpuFormDynamicItem_vue_vue_type_script_lang = require("./GpuFormDynamicItem.vue2.js");
 const vue = require("vue");
-const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
+const _pluginVue_exportHelper = require("../../../../_virtual/_plugin-vue_export-helper.js");
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_dao_option = vue.resolveComponent("dao-option");
   const _component_dao_select = vue.resolveComponent("dao-select");

package/dist/components/gpu/src/{GpuFormDynamicItem.vue.mjs → components/GpuFormDynamicItem.vue.mjs}

@@ -1,6 +1,6 @@
 import _sfc_main from "./GpuFormDynamicItem.vue2.mjs";
 import { resolveComponent, openBlock, createBlock, withCtx, createVNode, createElementBlock, Fragment, renderList } from "vue";
-import _export_sfc from "../../../_virtual/_plugin-vue_export-helper.mjs";
+import _export_sfc from "../../../../_virtual/_plugin-vue_export-helper.mjs";
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_dao_option = resolveComponent("dao-option");
   const _component_dao_select = resolveComponent("dao-select");

package/dist/components/gpu/src/{GpuFormDynamicItem.vue2.js → components/GpuFormDynamicItem.vue2.js}

@@ -4,7 +4,7 @@ const vueI18n = require("vue-i18n");
 const extend = require("@dao-style/extend");
 require("@dao-style/extend/dist/es/components/multi-row-editor/style/multi-row-editor");
 const lodashEs = require("lodash-es");
-const props = require("../props.js");
+const props = require("../../props.js");
 const _sfc_main = vue.defineComponent({
   components: {
     DaoMultiRowEditor: extend.DaoMultiRowEditor

package/dist/components/gpu/src/{GpuFormDynamicItem.vue2.mjs → components/GpuFormDynamicItem.vue2.mjs}

@@ -3,7 +3,7 @@ import { useI18n } from "vue-i18n";
 import { DaoMultiRowEditor } from "@dao-style/extend";
 import "@dao-style/extend/dist/es/components/multi-row-editor/style/multi-row-editor";
 import { isNil } from "lodash-es";
-import { dynamicGpuFormItemProps } from "../props.mjs";
+import { dynamicGpuFormItemProps } from "../../props.mjs";
 const _sfc_main = defineComponent({
   components: {
     DaoMultiRowEditor

package/dist/components/gpu/src/components/GpuFormItem.vue.d.ts

@@ -0,0 +1,310 @@
+import * as yup from 'yup';
+import '../../style/gpu-form-item';
+declare const _default: import("vue").DefineComponent<{
+    gpuSettingsAdaptor: {
+        type: import("vue").PropType<import("../../props").GPUSettings>;
+        default: undefined;
+    };
+    nvidiaVgpuModelsAdaptor: {
+        type: import("vue").PropType<{
+            data: import("../../types").GPUSummary[];
+            loading: boolean;
+            refresh: () => import("../../types").GPUSummary[] | Promise<import("../../types").GPUSummary[]>;
+        }>;
+        default: undefined;
+    };
+    nvidiaVgpuDevicesAdaptor: {
+        type: import("vue").PropType<import("../../props").GpuDevicesAdaptor>;
+        default: undefined;
+    };
+    targetType: {
+        type: StringConstructor;
+        default: string;
+    };
+    gpuUsage: {
+        type: import("vue").PropType<import("../../types").GpuUsage>;
+        default: string;
+    };
+    enableRemoteCall: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableRangeValidate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuModel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuModel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enableNvidiaVgpuDevices: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    assignGpuDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuDevices: {
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+    enableNvidiaVgpuPriority: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuPriority: {
+        type: import("vue").PropType<"0" | "1">;
+        default: undefined;
+    };
+    dynamicLimitOne: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuSchedulePolicy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuGpuSchedule: {
+        type: import("vue").PropType<import("../../types").VgpuSchedulePolicy>;
+        default: undefined;
+    };
+    nvidiaVgpuNodeSchedule: {
+        type: import("vue").PropType<import("../../types").VgpuSchedulePolicy>;
+        default: undefined;
+    };
+    quotaItem: {
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
+        default: () => {};
+    };
+    isSide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    gpuProvider: {
+        type: StringConstructor;
+        default: string;
+    };
+    availableQuotaItem: {
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
+        default: undefined;
+    };
+    usedQuotaItem: {
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
+        default: undefined;
+    };
+    existTypes: {
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+    gpuOptionsMap: {
+        type: import("vue").PropType<Map<string, import("../../types").GPUSetting>>;
+        required: boolean;
+    };
+    nvidiaGpuModels: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+    };
+    getDisplayResource: {
+        type: import("vue").PropType<(type: string) => import("../../types").GPUResourceSetting[]>;
+        required: boolean;
+    };
+    nvidiaGpuDevices: {
+        type: import("vue").PropType<import("../../props").GpuDevice[]>;
+        default: () => never[];
+    };
+}, {
+    nvidiaVgpuModelKey: string;
+    nvidiaVgpuPriorityKey: string;
+    yup: typeof yup;
+    isNvidiaVgpu: (key?: string | undefined) => boolean;
+    isNvidiaMig: (key?: string | undefined) => boolean;
+    quota: import("../../types").GpuQuotaItem;
+    dynamicQuota: import("vue").Ref<Record<string, string | number | undefined> | undefined>;
+    currentDisplayResource: import("vue").ComputedRef<import("../../types").GPUResourceSetting[] | undefined>;
+    currentGpuProvider: import("vue").ComputedRef<string>;
+    isShowHamiGpuHelper: import("vue").ComputedRef<boolean>;
+    filteredGpuOptionsMap: import("vue").ComputedRef<Map<string, import("../../types").GPUSetting>>;
+    getGPUTypeInSide: (quotaType?: string | undefined) => string;
+    handleTypeChange: (val: unknown) => void;
+    validate: () => Promise<import("vee-validate").FormValidationResult<import("../../types").GpuQuotaItem>> | {
+        valid: boolean;
+    };
+    deSanitizeGPUObjectKey: <T extends Record<string, unknown>>(obj?: T | undefined) => T;
+    gpuResourceHelperSlot: () => string[] | undefined;
+    openNvidiaVgpuModel: import("vue").Ref<boolean>;
+    openNvidiaAssignGpu: import("vue").Ref<boolean>;
+    openNvidiaVgpuSchedulePolicy: import("vue").Ref<boolean>;
+    gpuAdvancedFormProps: import("vue").ComputedRef<{
+        enableRemoteCall: boolean;
+        enableNvidiaVgpuModel: boolean;
+        enableNvidiaVgpuDevices: boolean;
+        assignGpuDisabled: boolean;
+        enableNvidiaVgpuPriority: boolean;
+        enableNvidiaVgpuSchedulePolicy: boolean;
+        nvidiaGpuModels: string[] | undefined;
+        nvidiaVgpuModelsAdaptor: {
+            data: import("../../types").GPUSummary[];
+            loading: boolean;
+            refresh: () => import("../../types").GPUSummary[] | Promise<import("../../types").GPUSummary[]>;
+        } | undefined;
+        nvidiaVgpuDevicesAdaptor: import("../../props").GpuDevicesAdaptor | undefined;
+        isSide: boolean;
+    }>;
+    showDynamicForm: import("vue").ComputedRef<boolean | undefined>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "refreshGpuOptionsMap")[], "change" | "refreshGpuOptionsMap", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    gpuSettingsAdaptor: {
+        type: import("vue").PropType<import("../../props").GPUSettings>;
+        default: undefined;
+    };
+    nvidiaVgpuModelsAdaptor: {
+        type: import("vue").PropType<{
+            data: import("../../types").GPUSummary[];
+            loading: boolean;
+            refresh: () => import("../../types").GPUSummary[] | Promise<import("../../types").GPUSummary[]>;
+        }>;
+        default: undefined;
+    };
+    nvidiaVgpuDevicesAdaptor: {
+        type: import("vue").PropType<import("../../props").GpuDevicesAdaptor>;
+        default: undefined;
+    };
+    targetType: {
+        type: StringConstructor;
+        default: string;
+    };
+    gpuUsage: {
+        type: import("vue").PropType<import("../../types").GpuUsage>;
+        default: string;
+    };
+    enableRemoteCall: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableRangeValidate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuModel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuModel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    enableNvidiaVgpuDevices: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    assignGpuDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuDevices: {
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+    enableNvidiaVgpuPriority: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuPriority: {
+        type: import("vue").PropType<"0" | "1">;
+        default: undefined;
+    };
+    dynamicLimitOne: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    enableNvidiaVgpuSchedulePolicy: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nvidiaVgpuGpuSchedule: {
+        type: import("vue").PropType<import("../../types").VgpuSchedulePolicy>;
+        default: undefined;
+    };
+    nvidiaVgpuNodeSchedule: {
+        type: import("vue").PropType<import("../../types").VgpuSchedulePolicy>;
+        default: undefined;
+    };
+    quotaItem: {
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
+        default: () => {};
+    };
+    isSide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    gpuProvider: {
+        type: StringConstructor;
+        default: string;
+    };
+    availableQuotaItem: {
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
+        default: undefined;
+    };
+    usedQuotaItem: {
+        type: import("vue").PropType<import("../../types").GpuQuotaItem>;
+        default: undefined;
+    };
+    existTypes: {
+        type: import("vue").PropType<string[]>;
+        default: () => never[];
+    };
+    gpuOptionsMap: {
+        type: import("vue").PropType<Map<string, import("../../types").GPUSetting>>;
+        required: boolean;
+    };
+    nvidiaGpuModels: {
+        type: import("vue").PropType<string[]>;
+        required: boolean;
+    };
+    getDisplayResource: {
+        type: import("vue").PropType<(type: string) => import("../../types").GPUResourceSetting[]>;
+        required: boolean;
+    };
+    nvidiaGpuDevices: {
+        type: import("vue").PropType<import("../../props").GpuDevice[]>;
+        default: () => never[];
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    onRefreshGpuOptionsMap?: ((...args: any[]) => any) | undefined;
+}, {
+    nvidiaVgpuModel: string;
+    nvidiaVgpuDevices: string[];
+    nvidiaVgpuGpuSchedule: import("../../types").VgpuSchedulePolicy;
+    nvidiaVgpuNodeSchedule: import("../../types").VgpuSchedulePolicy;
+    gpuSettingsAdaptor: import("../../props").GPUSettings;
+    nvidiaVgpuModelsAdaptor: {
+        data: import("../../types").GPUSummary[];
+        loading: boolean;
+        refresh: () => import("../../types").GPUSummary[] | Promise<import("../../types").GPUSummary[]>;
+    };
+    nvidiaVgpuDevicesAdaptor: import("../../props").GpuDevicesAdaptor;
+    targetType: string;
+    gpuUsage: import("../../types").GpuUsage;
+    enableRemoteCall: boolean;
+    enableRangeValidate: boolean;
+    enableNvidiaVgpuModel: boolean;
+    enableNvidiaVgpuDevices: boolean;
+    assignGpuDisabled: boolean;
+    enableNvidiaVgpuPriority: boolean;
+    nvidiaVgpuPriority: "0" | "1";
+    dynamicLimitOne: boolean;
+    enableNvidiaVgpuSchedulePolicy: boolean;
+    quotaItem: import("../../types").GpuQuotaItem;
+    isSide: boolean;
+    gpuProvider: string;
+    availableQuotaItem: import("../../types").GpuQuotaItem;
+    usedQuotaItem: import("../../types").GpuQuotaItem;
+    existTypes: string[];
+    nvidiaGpuDevices: import("../../props").GpuDevice[];
+}>;
+export default _default;

package/dist/components/gpu/src/{GpuFormItem.vue.js → components/GpuFormItem.vue.js}

@@ -1,7 +1,7 @@
 "use strict";
 const GpuFormItem_vue_vue_type_script_lang = require("./GpuFormItem.vue2.js");
 const vue = require("vue");
-const _pluginVue_exportHelper = require("../../../_virtual/_plugin-vue_export-helper.js");
+const _pluginVue_exportHelper = require("../../../../_virtual/_plugin-vue_export-helper.js");
 const _hoisted_1 = { class: "gpu-quotas-item__type-select-wrap" };
 const _hoisted_2 = { key: 0 };
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
@@ -10,7 +10,6 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_dao_select = vue.resolveComponent("dao-select");
   const _component_dao_action_icon = vue.resolveComponent("dao-action-icon");
   const _component_dao_history_link = vue.resolveComponent("dao-history-link");
-  const _component_dao_message = vue.resolveComponent("dao-message");
   const _component_dao_helper_text = vue.resolveComponent("dao-helper-text");
   const _component_dao_form_item_validate = vue.resolveComponent("dao-form-item-validate");
   const _component_gpu_form_dynamic_item = vue.resolveComponent("gpu-form-dynamic-item");
@@ -92,20 +91,12 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
             })
           ]),
           key: "0"
-        } : _ctx.isNvidiaVgpu(_ctx.quota.type) && !_ctx.isSide ? {
+        } : _ctx.isShowHamiGpuHelper ? {
           name: "helper",
           fn: vue.withCtx(() => [
             vue.createVNode(_component_dao_helper_text, null, {
               default: vue.withCtx(() => [
-                vue.createVNode(_component_dao_message, {
-                  simple: "",
-                  type: "info"
-                }, {
-                  default: vue.withCtx(() => [
-                    vue.createTextVNode(vue.toDisplayString(_ctx.$t("biz.components.Gpu.hashrateTip")), 1)
-                  ]),
-                  _: 1
-                })
+                vue.createTextVNode(vue.toDisplayString(_ctx.$t("biz.components.Gpu.hashrateTip")), 1)
               ]),
               _: 1
             })
@@ -159,7 +150,9 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
           "available-quota-item": _ctx.availableQuotaItem,
           "is-side": _ctx.isSide,
           "enable-range-validate": _ctx.enableRangeValidate,
-          "quota-item": _ctx.quotaItem
+          "quota-item": _ctx.quotaItem,
+          "gpu-provider": _ctx.currentGpuProvider,
+          "gpu-usage": _ctx.gpuUsage
         }, vue.createSlots({ _: 2 }, [
           vue.renderList(_ctx.gpuResourceHelperSlot, (resourceKey) => {
             return {
@@ -169,21 +162,24 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
               ])
             };
           })
-        ]), 1032, ["resources", "quota", "used-quota-item", "available-quota-item", "is-side", "enable-range-validate", "quota-item"])),
-        vue.createVNode(_component_gpu_advanced_form, {
+        ]), 1032, ["resources", "quota", "used-quota-item", "available-quota-item", "is-side", "enable-range-validate", "quota-item", "gpu-provider", "gpu-usage"])),
+        vue.createVNode(_component_gpu_advanced_form, vue.mergeProps({
           "open-nvidia-vgpu-model": _ctx.openNvidiaVgpuModel,
           "onUpdate:openNvidiaVgpuModel": _cache[2] || (_cache[2] = ($event) => _ctx.openNvidiaVgpuModel = $event),
-          "open-nvidia-vgpu-scheule-policy": _ctx.openNvidiaVgpuScheulePolicy,
-          "onUpdate:openNvidiaVgpuScheulePolicy": _cache[3] || (_cache[3] = ($event) => _ctx.openNvidiaVgpuScheulePolicy = $event),
-          quota: _ctx.quota,
-          "enable-remote-call": _ctx.enableRemoteCall,
-          "enable-nvidia-vgpu-model": _ctx.enableNvidiaVgpuModel,
-          "enable-nvidia-vgpu-priority": _ctx.enableNvidiaVgpuPriority,
-          "enable-nvidia-vgpu-schedule-policy": _ctx.enableNvidiaVgpuSchedulePolicy,
-          "nvidia-gpu-models": _ctx.nvidiaGpuModels,
-          "nvidia-vgpu-models-adaptor": _ctx.nvidiaVgpuModelsAdaptor,
-          "is-side": _ctx.isSide
-        }, null, 8, ["open-nvidia-vgpu-model", "open-nvidia-vgpu-scheule-policy", "quota", "enable-remote-call", "enable-nvidia-vgpu-model", "enable-nvidia-vgpu-priority", "enable-nvidia-vgpu-schedule-policy", "nvidia-gpu-models", "nvidia-vgpu-models-adaptor", "is-side"])
+          "open-nvidia-assign-gpu": _ctx.openNvidiaAssignGpu,
+          "onUpdate:openNvidiaAssignGpu": _cache[3] || (_cache[3] = ($event) => _ctx.openNvidiaAssignGpu = $event),
+          "open-nvidia-vgpu-schedule-policy": _ctx.openNvidiaVgpuSchedulePolicy,
+          "onUpdate:openNvidiaVgpuSchedulePolicy": _cache[4] || (_cache[4] = ($event) => _ctx.openNvidiaVgpuSchedulePolicy = $event),
+          quota: _ctx.quotaItem
+        }, _ctx.gpuAdvancedFormProps), vue.createSlots({ _: 2 }, [
+          _ctx.$slots["assign-gpu-disabled-message"] ? {
+            name: "assign-gpu-disabled-message",
+            fn: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "assign-gpu-disabled-message")
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1040, ["open-nvidia-vgpu-model", "open-nvidia-assign-gpu", "open-nvidia-vgpu-schedule-policy", "quota"])
       ], 64))
     ]),
     _: 3