@daocloud-proto/baize 0.111.0 → 0.111.2

package/management-api/cluster/v1alpha1/cluster.pb.ts

@@ -19,6 +19,7 @@ export type AICluster = {
   name?: string
   withAiSuite?: boolean
   clusterStatus?: ClusterStatus
+  withMetricsServer?: boolean
 }
 
 export type ListAIClustersRequest = {

package/management-api/dataset/v1alpha1/dataset.pb.ts

@@ -7,6 +7,7 @@
 import * as BaizeCommonCommon from "../../../common/common.pb"
 import * as fm from "../../../fetch.pb"
 import * as GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
+import * as BaizeManagement_apiEventV1alpha1Event from "../../event/v1alpha1/event.pb"
 import * as BaizeManagement_apiWorkspaceV1alpha1Workspace from "../../workspace/v1alpha1/workspace.pb"
 
 type Absent<T, K extends keyof T> = { [k in Exclude<keyof T, K>]?: undefined };
@@ -236,10 +237,11 @@ export type SingleDatasetRequest = {
   secretOptions?: SecretOptions
   share?: boolean
   sharedStoWorkspaces?: number[]
+  uri?: string
 }
 
 export type UpdateDatasetRequest = BaseUpdateDatasetRequest
-  & OneOf<{ conda: DataSourceOptionsConda }>
+  & OneOf<{ git: DataSourceOptionsGit; s3: DataSourceOptionsS3; http: DataSourceOptionsHttp; conda: DataSourceOptionsConda; huggingFace: DataSourceOptionsHuggingFace; modelScope: DataSourceOptionsModelScope }>
 
 export type DatasetActionRequest = {
   workspace?: number
@@ -290,6 +292,14 @@ export type ValidateDataSourceSecretsResponse = {
   message?: string
 }
 
+export type ListDatasetEventsRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  page?: BaizeCommonCommon.Pagination
+}
+
 export class DatasetManagement {
   static ListDatasets(req: ListDatasetRequest, initReq?: fm.InitReq): Promise<ListDatasetResponse> {
     return fm.fetchReq<ListDatasetRequest, ListDatasetResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/datasets?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
@@ -297,6 +307,9 @@ export class DatasetManagement {
   static GetDataset(req: SingleDatasetRequest, initReq?: fm.InitReq): Promise<Dataset> {
     return fm.fetchReq<SingleDatasetRequest, Dataset>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/datasets/${req["name"]}?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
+  static ListDatasetEvents(req: ListDatasetEventsRequest, initReq?: fm.InitReq): Promise<BaizeManagement_apiEventV1alpha1Event.ListEventsResponse> {
+    return fm.fetchReq<ListDatasetEventsRequest, BaizeManagement_apiEventV1alpha1Event.ListEventsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/datasets/${req["name"]}/events?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
   static GetDatasetSyncProcess(req: SingleDatasetRequest, initReq?: fm.InitReq): Promise<DatasetSyncProcess> {
     return fm.fetchReq<SingleDatasetRequest, DatasetSyncProcess>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/datasets/${req["name"]}/sync-process?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }

package/management-api/device/v1alpha1/device.pb.ts

@@ -19,6 +19,7 @@ export type DeviceGPU = {
   vendor?: string
   totalFrameBufferMemory?: string
   usedFrameBufferMemory?: string
+  nodeName?: string
 }
 
 export type ListDevicesGPUsResponse = {

package/management-api/event/v1alpha1/event.pb.ts

@@ -0,0 +1,51 @@
+/* eslint-disable */
+// @ts-nocheck
+/*
+* This file is a generated Typescript file for GRPC Gateway, DO NOT MODIFY
+*/
+
+import * as BaizeCommonCommon from "../../../common/common.pb"
+import * as GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
+
+export enum EventObjKind {
+  KIND_UNSPECIFIED = "KIND_UNSPECIFIED",
+  ANALYTICS = "ANALYTICS",
+  DATASET = "DATASET",
+  MODEL = "MODEL",
+  INFERENCE = "INFERENCE",
+  LABELING = "LABELING",
+  NOTEBOOK = "NOTEBOOK",
+  QUEUE = "QUEUE",
+  LOCAL_QUEUE = "LOCAL_QUEUE",
+  POD = "POD",
+  QUEUE_WORKLOAD = "QUEUE_WORKLOAD",
+  PYTORCH_JOB = "PYTORCH_JOB",
+  TF_JOB = "TF_JOB",
+  PADDLE_JOB = "PADDLE_JOB",
+  MXNET_JOB = "MXNET_JOB",
+  MPI_JOB = "MPI_JOB",
+  UNKNOWN = "UNKNOWN",
+}
+
+export enum EventType {
+  TYPE_UNSPECIFIED = "TYPE_UNSPECIFIED",
+  NORMAL = "NORMAL",
+  WARNING = "WARNING",
+}
+
+export type Event = {
+  objKind?: EventObjKind
+  objName?: string
+  objNamespace?: string
+  type?: EventType
+  message?: string
+  reason?: string
+  firstTimestamp?: GoogleProtobufTimestamp.Timestamp
+  lastTimestamp?: GoogleProtobufTimestamp.Timestamp
+  count?: number
+}
+
+export type ListEventsResponse = {
+  items?: Event[]
+  page?: BaizeCommonCommon.Pagination
+}

package/management-api/job/v1alpha1/job.pb.ts

@@ -10,6 +10,7 @@ import * as fm from "../../../fetch.pb"
 import * as GoogleProtobufStruct from "../../../google/protobuf/struct.pb"
 import * as GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
 import * as BaizeManagement_apiAnalysisV1alpha1Analysis from "../../analysis/v1alpha1/analysis.pb"
+import * as BaizeManagement_apiEventV1alpha1Event from "../../event/v1alpha1/event.pb"
 import * as BaizeManagement_apiJobV1alpha1Common from "./common.pb"
 
 type Absent<T, K extends keyof T> = { [k in Exclude<keyof T, K>]?: undefined };
@@ -145,6 +146,15 @@ export type JobSchedulersResponse = {
   items?: JobSchedulersResponseScheduler[]
 }
 
+export type ListJobEventsRequest = {
+  workspace?: number
+  type?: JobType
+  cluster?: string
+  namespace?: string
+  name?: string
+  page?: BaizeCommonCommon.Pagination
+}
+
 export class JobsManagement {
   static ListJobs(req: ListJobsRequest, initReq?: fm.InitReq): Promise<ListJobsResponse> {
     return fm.fetchReq<ListJobsRequest, ListJobsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/jobs?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
@@ -152,6 +162,9 @@ export class JobsManagement {
   static GetJob(req: SingleJobRequest, initReq?: fm.InitReq): Promise<Job> {
     return fm.fetchReq<SingleJobRequest, Job>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs/${req["name"]}?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
+  static ListJobEvents(req: ListJobEventsRequest, initReq?: fm.InitReq): Promise<BaizeManagement_apiEventV1alpha1Event.ListEventsResponse> {
+    return fm.fetchReq<ListJobEventsRequest, BaizeManagement_apiEventV1alpha1Event.ListEventsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs/${req["name"]}/events?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
   static CreateJob(req: CreateJobRequest, initReq?: fm.InitReq): Promise<Job> {
     return fm.fetchReq<CreateJobRequest, Job>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/jobs`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
   }

package/management-api/model/v1alpha1/model.pb.ts

@@ -109,6 +109,7 @@ export type Model = {
   readme?: string
   status?: ModelStatus
   displayName?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
 }
 
 export type ListModelsRequest = {

package/management-api/notebook/v1alpha1/notebook.pb.ts

@@ -9,6 +9,7 @@ import * as BaizeCommonK8s from "../../../common/k8s.pb"
 import * as fm from "../../../fetch.pb"
 import * as GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
 import * as BaizeManagement_apiAnalysisV1alpha1Analysis from "../../analysis/v1alpha1/analysis.pb"
+import * as BaizeManagement_apiEventV1alpha1Event from "../../event/v1alpha1/event.pb"
 import * as BaizeManagement_apiImageV1alpha1Image from "../../image/v1alpha1/image.pb"
 
 type Absent<T, K extends keyof T> = { [k in Exclude<keyof T, K>]?: undefined };
@@ -226,6 +227,14 @@ export type NotebookConnectionInfo = {
   ssh?: NotebookConnectionInfoSSH
 }
 
+export type ListNotebookEventsRequest = {
+  workspace?: number
+  cluster?: string
+  namespace?: string
+  name?: string
+  page?: BaizeCommonCommon.Pagination
+}
+
 export class NotebookService {
   static ListNotebooks(req: ListNotebooksRequest, initReq?: fm.InitReq): Promise<ListNotebooksResponse> {
     return fm.fetchReq<ListNotebooksRequest, ListNotebooksResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/notebooks?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
@@ -233,6 +242,9 @@ export class NotebookService {
   static GetNotebook(req: SingleNotebookRequest, initReq?: fm.InitReq): Promise<Notebook> {
     return fm.fetchReq<SingleNotebookRequest, Notebook>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/notebooks/${req["name"]}?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
+  static ListNotebookEvents(req: ListNotebookEventsRequest, initReq?: fm.InitReq): Promise<BaizeManagement_apiEventV1alpha1Event.ListEventsResponse> {
+    return fm.fetchReq<ListNotebookEventsRequest, BaizeManagement_apiEventV1alpha1Event.ListEventsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/notebooks/${req["name"]}/events?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
   static GetNotebookConnectionInfo(req: SingleNotebookRequest, initReq?: fm.InitReq): Promise<NotebookConnectionInfo> {
     return fm.fetchReq<SingleNotebookRequest, NotebookConnectionInfo>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/notebooks/${req["name"]}/connections?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }

package/management-api/permission/v1alpha1/permission.pb.ts

@@ -6,12 +6,38 @@
 
 import * as BaizeCommonCommon from "../../../common/common.pb"
 import * as fm from "../../../fetch.pb"
+export type Permission = {
+  resourceType?: string
+  actions?: string[]
+}
+
 export type UserPermission = {
   isBaizeOwner?: boolean
 }
 
+export type GetCurrentUserWorkspacePermissionRequest = {
+  workspaceId?: number
+}
+
+export type GetCurrentUserWorkspacePermissionResponse = {
+  permission?: Permission[]
+}
+
+export type GetCurrentUserOperatorPermissionRequest = {
+}
+
+export type GetCurrentUserOperatorPermissionResponse = {
+  permission?: Permission[]
+}
+
 export class PermissionService {
   static GetCurrentUserPermission(req: BaizeCommonCommon.NoParamsQuery, initReq?: fm.InitReq): Promise<UserPermission> {
     return fm.fetchReq<BaizeCommonCommon.NoParamsQuery, UserPermission>(`/apis/baize.io/v1alpha1/current-user/permission?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
   }
+  static GetCurrentUserWorkspacePermissions(req: GetCurrentUserWorkspacePermissionRequest, initReq?: fm.InitReq): Promise<GetCurrentUserWorkspacePermissionResponse> {
+    return fm.fetchReq<GetCurrentUserWorkspacePermissionRequest, GetCurrentUserWorkspacePermissionResponse>(`/apis/baize.io/v1alpha1/current-user/ws-permissions?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
+  static GetCurrentUserOperatorPermissions(req: GetCurrentUserOperatorPermissionRequest, initReq?: fm.InitReq): Promise<GetCurrentUserOperatorPermissionResponse> {
+    return fm.fetchReq<GetCurrentUserOperatorPermissionRequest, GetCurrentUserOperatorPermissionResponse>(`/apis/baize.io/v1alpha1/current-user/operator-permissions?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
+  }
 }

package/management-api/queue/v1alpha1/queue.pb.ts

@@ -5,7 +5,9 @@
 */
 
 import * as BaizeCommonCommon from "../../../common/common.pb"
+import * as BaizeCommonK8s from "../../../common/k8s.pb"
 import * as fm from "../../../fetch.pb"
+import * as GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
 
 export enum QueueType {
   QUEUE_TYPE_UNSPECIFIED = "QUEUE_TYPE_UNSPECIFIED",
@@ -44,6 +46,12 @@ export enum QueuePreemptionBorrowWithinCohortPolicy {
   QUEUE_PREEMPTION_BORROW_WITHIN_COHORT_POLICY_LOWER_PRIORITY = "QUEUE_PREEMPTION_BORROW_WITHIN_COHORT_POLICY_LOWER_PRIORITY",
 }
 
+export enum QueueWorkloadPhase {
+  PHASE_UNSPECIFIED = "PHASE_UNSPECIFIED",
+  PENDING = "PENDING",
+  ADMITTED = "ADMITTED",
+}
+
 export type QueueResource = {
   name?: string
   value?: string
@@ -153,6 +161,34 @@ export type CreateLocalQueueResponse = {
   status?: QueueStatus
 }
 
+export type QueueWorkload = {
+  cluster?: string
+  namespace?: string
+  queueName?: string
+  name?: string
+  totalPods?: number
+  totalResources?: BaizeCommonK8s.Resources
+  priorityClassName?: string
+  priority?: number
+  schedulerName?: string
+  preemptionPolicy?: string
+  creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  phase?: QueueWorkloadPhase
+}
+
+export type ListQueueWorkloadRequest = {
+  cluster?: string
+  namespace?: string
+  queueName?: string
+  type?: QueueType
+  page?: BaizeCommonCommon.Pagination
+}
+
+export type ListQueueWorkloadResponse = {
+  items?: QueueWorkload[]
+  page?: BaizeCommonCommon.Pagination
+}
+
 export class QueueManagement {
   static ListQueues(req: ListQueueRequest, initReq?: fm.InitReq): Promise<ListQueueResponse> {
     return fm.fetchReq<ListQueueRequest, ListQueueResponse>(`/apis/baize.io/v1alpha1/queues?${fm.renderURLSearchParams(req, [])}`, {...initReq, method: "GET"})
@@ -178,4 +214,7 @@ export class QueueManagement {
   static CreateLocalQueue(req: CreateLocalQueueRequest, initReq?: fm.InitReq): Promise<CreateLocalQueueResponse> {
     return fm.fetchReq<CreateLocalQueueRequest, CreateLocalQueueResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/localqueues`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
   }
+  static ListQueueWorkloads(req: ListQueueWorkloadRequest, initReq?: fm.InitReq): Promise<ListQueueWorkloadResponse> {
+    return fm.fetchReq<ListQueueWorkloadRequest, ListQueueWorkloadResponse>(`/apis/baize.io/v1alpha1/clusters/${req["cluster"]}/queues/${req["queueName"]}/workloads?${fm.renderURLSearchParams(req, ["cluster", "queueName"])}`, {...initReq, method: "GET"})
+  }
 }

package/management-api/serving/v1alpha1/serving.pb.ts

@@ -8,6 +8,8 @@ import * as BaizeCommonCommon from "../../../common/common.pb"
 import * as BaizeCommonK8s from "../../../common/k8s.pb"
 import * as fm from "../../../fetch.pb"
 import * as GoogleProtobufTimestamp from "../../../google/protobuf/timestamp.pb"
+import * as GoogleProtobufWrappers from "../../../google/protobuf/wrappers.pb"
+import * as BaizeManagement_apiEventV1alpha1Event from "../../event/v1alpha1/event.pb"
 import * as BaizeManagement_apiServingTritonModel_config from "../triton/model_config.pb"
 
 type Absent<T, K extends keyof T> = { [k in Exclude<keyof T, K>]?: undefined };
@@ -135,6 +137,7 @@ export type InferenceServing = {
   lastUpdated?: GoogleProtobufTimestamp.Timestamp
   authType?: ServingAuthAuthType
   creationTimestamp?: GoogleProtobufTimestamp.Timestamp
+  hpaConfig?: HPAConfig
 }
 
 export type InferenceServingStatusModelStatus = {
@@ -162,6 +165,22 @@ export type ServingAuthTritonRestrictedKeyValue = {
 export type ServingAuth = BaseServingAuth
   & OneOf<{ tritonRestrictedKeyValue: ServingAuthTritonRestrictedKeyValue }>
 
+export type HPAConfig = {
+  enabled?: boolean
+  minReplicas?: number
+  maxReplicas?: number
+  metrics?: Metrics[]
+  scaleUpStabilizationWindowSeconds?: GoogleProtobufWrappers.Int32Value
+  scaleDownStabilizationWindowSeconds?: GoogleProtobufWrappers.Int32Value
+}
+
+export type Metrics = {
+  name?: string
+  value?: GoogleProtobufWrappers.Int32Value
+  avgValue?: GoogleProtobufWrappers.Int32Value
+  utilizationPercentage?: GoogleProtobufWrappers.Int32Value
+}
+
 export type CreateInferenceServingRequest = {
   workspace?: number
   name?: string
@@ -175,6 +194,7 @@ export type CreateInferenceServingRequest = {
   podConfig?: BaizeCommonK8s.PodConfig
   framework?: Framework
   auth?: ServingAuth
+  hpaConfig?: HPAConfig
 }
 
 export type UpdateInferenceServingRequest = {
@@ -188,6 +208,7 @@ export type UpdateInferenceServingRequest = {
   annotations?: {[key: string]: string}
   podConfig?: BaizeCommonK8s.PodConfig
   auth?: ServingAuth
+  hpaConfig?: HPAConfig
 }
 
 export type SingleInferenceServingRequest = {
@@ -209,6 +230,25 @@ export type ListInferenceServingsResponse = {
   page?: BaizeCommonCommon.Pagination
 }
 
+export type GetServingHPARequest = {
+  name?: string
+  cluster?: string
+  namespace?: string
+  workspace?: number
+}
+
+export type GetServingHPAResponse = {
+  data?: string
+}
+
+export type ListInferenceEventsRequest = {
+  cluster?: string
+  namespace?: string
+  workspace?: number
+  name?: string
+  page?: BaizeCommonCommon.Pagination
+}
+
 export class InferenceServingManagement {
   static CreateInferenceServing(req: CreateInferenceServingRequest, initReq?: fm.InitReq): Promise<InferenceServing> {
     return fm.fetchReq<CreateInferenceServingRequest, InferenceServing>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/inference-serving`, {...initReq, method: "POST", body: JSON.stringify(req, fm.replacer)})
@@ -216,6 +256,12 @@ export class InferenceServingManagement {
   static GetInferenceServing(req: SingleInferenceServingRequest, initReq?: fm.InitReq): Promise<InferenceServing> {
     return fm.fetchReq<SingleInferenceServingRequest, InferenceServing>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/inference-serving/${req["name"]}?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
   }
+  static GetInferenceServingHPA(req: GetServingHPARequest, initReq?: fm.InitReq): Promise<GetServingHPAResponse> {
+    return fm.fetchReq<GetServingHPARequest, GetServingHPAResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/inference-serving/${req["name"]}/hpa?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
+  static ListInferenceEvents(req: ListInferenceEventsRequest, initReq?: fm.InitReq): Promise<BaizeManagement_apiEventV1alpha1Event.ListEventsResponse> {
+    return fm.fetchReq<ListInferenceEventsRequest, BaizeManagement_apiEventV1alpha1Event.ListEventsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/clusters/${req["cluster"]}/namespaces/${req["namespace"]}/inference-serving/${req["name"]}/events?${fm.renderURLSearchParams(req, ["workspace", "cluster", "namespace", "name"])}`, {...initReq, method: "GET"})
+  }
   static ListInferenceServings(req: ListInferenceServingsRequest, initReq?: fm.InitReq): Promise<ListInferenceServingsResponse> {
     return fm.fetchReq<ListInferenceServingsRequest, ListInferenceServingsResponse>(`/apis/baize.io/v1alpha1/workspaces/${req["workspace"]}/inference-serving?${fm.renderURLSearchParams(req, ["workspace"])}`, {...initReq, method: "GET"})
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daocloud-proto/baize",
-  "version": "v0.111.0",
+  "version": "v0.111.2",
   "description": "",
   "author": "",
   "license": "ISC"