863 lines
37 KiB
Go
863 lines
37 KiB
Go
/*
|
|
* Model Registry REST API
|
|
*
|
|
* REST API for Model Registry to create and manage ML model metadata
|
|
*
|
|
* API version: 1.0.0
|
|
* Generated by: OpenAPI Generator (https://openapi-generator.tech)
|
|
*/
|
|
|
|
package openapi
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/kubeflow/model-registry/internal/apiutils"
|
|
"github.com/kubeflow/model-registry/internal/converter"
|
|
"github.com/kubeflow/model-registry/internal/converter/generated"
|
|
"github.com/kubeflow/model-registry/pkg/api"
|
|
model "github.com/kubeflow/model-registry/pkg/openapi"
|
|
)
|
|
|
|
// ModelRegistryServiceAPIService is a service that implements the logic for the ModelRegistryServiceAPIServicer
|
|
// This service should implement the business logic for every endpoint for the ModelRegistryServiceAPI s.coreApi.
|
|
// Include any external packages or services that will be required by this service.
|
|
type ModelRegistryServiceAPIService struct {
|
|
coreApi api.ModelRegistryApi
|
|
converter converter.OpenAPIConverter
|
|
reconciler converter.OpenAPIReconciler
|
|
}
|
|
|
|
// NewModelRegistryServiceAPIService creates a default api service
|
|
func NewModelRegistryServiceAPIService(coreApi api.ModelRegistryApi) ModelRegistryServiceAPIServicer {
|
|
return &ModelRegistryServiceAPIService{
|
|
coreApi: coreApi,
|
|
converter: &generated.OpenAPIConverterImpl{},
|
|
reconciler: &generated.OpenAPIReconcilerImpl{},
|
|
}
|
|
}
|
|
|
|
// CreateEnvironmentInferenceService - Create a InferenceService in ServingEnvironment
|
|
func (s *ModelRegistryServiceAPIService) CreateEnvironmentInferenceService(ctx context.Context, servingenvironmentId string, inferenceServiceCreate model.InferenceServiceCreate) (ImplResponse, error) {
|
|
inferenceServiceCreate.ServingEnvironmentId = servingenvironmentId
|
|
return s.CreateInferenceService(ctx, inferenceServiceCreate)
|
|
// TODO: return Response(http.StatusNotFound, Error{}), nil
|
|
}
|
|
|
|
// CreateInferenceService - Create a InferenceService
|
|
func (s *ModelRegistryServiceAPIService) CreateInferenceService(ctx context.Context, inferenceServiceCreate model.InferenceServiceCreate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertInferenceServiceCreate(&inferenceServiceCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertInferenceService(entity)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateInferenceServiceServe - Create a ServeModel action in a InferenceService
|
|
func (s *ModelRegistryServiceAPIService) CreateInferenceServiceServe(ctx context.Context, inferenceserviceId string, serveModelCreate model.ServeModelCreate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertServeModelCreate(&serveModelCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertServeModel(entity, &inferenceserviceId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateArtifact - Create an Artifact
|
|
func (s *ModelRegistryServiceAPIService) CreateArtifact(ctx context.Context, artifactCreate model.ArtifactCreate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertArtifactCreate(&artifactCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertArtifact(entity)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateModelArtifact - Create a ModelArtifact
|
|
func (s *ModelRegistryServiceAPIService) CreateModelArtifact(ctx context.Context, modelArtifactCreate model.ModelArtifactCreate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertModelArtifactCreate(&modelArtifactCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertModelArtifact(entity)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateModelVersion - Create a ModelVersion
|
|
func (s *ModelRegistryServiceAPIService) CreateModelVersion(ctx context.Context, modelVersionCreate model.ModelVersionCreate) (ImplResponse, error) {
|
|
modelVersion, err := s.converter.ConvertModelVersionCreate(&modelVersionCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertModelVersion(modelVersion, &modelVersionCreate.RegisteredModelId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateModelVersionArtifact - Create an Artifact in a ModelVersion
|
|
func (s *ModelRegistryServiceAPIService) UpsertModelVersionArtifact(ctx context.Context, modelversionId string, artifact model.Artifact) (ImplResponse, error) {
|
|
creating := (artifact.DocArtifact != nil && artifact.DocArtifact.Id == nil) || (artifact.ModelArtifact != nil && artifact.ModelArtifact.Id == nil)
|
|
|
|
result, err := s.coreApi.UpsertModelVersionArtifact(&artifact, modelversionId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
if creating {
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
// return Response(http.StatusNotImplemented, nil), errors.New("unsupported artifactType")
|
|
// TODO return Response(http.StatusOK, Artifact{}), nil
|
|
}
|
|
|
|
// CreateRegisteredModel - Create a RegisteredModel
|
|
func (s *ModelRegistryServiceAPIService) CreateRegisteredModel(ctx context.Context, registeredModelCreate model.RegisteredModelCreate) (ImplResponse, error) {
|
|
registeredModel, err := s.converter.ConvertRegisteredModelCreate(®isteredModelCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertRegisteredModel(registeredModel)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateRegisteredModelVersion - Create a ModelVersion in RegisteredModel
|
|
func (s *ModelRegistryServiceAPIService) CreateRegisteredModelVersion(ctx context.Context, registeredmodelId string, modelVersion model.ModelVersion) (ImplResponse, error) {
|
|
result, err := s.coreApi.UpsertModelVersion(&modelVersion, apiutils.StrPtr(registeredmodelId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateServingEnvironment - Create a ServingEnvironment
|
|
func (s *ModelRegistryServiceAPIService) CreateServingEnvironment(ctx context.Context, servingEnvironmentCreate model.ServingEnvironmentCreate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertServingEnvironmentCreate(&servingEnvironmentCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertServingEnvironment(entity)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// FindInferenceService - Get an InferenceServices that matches search parameters.
|
|
func (s *ModelRegistryServiceAPIService) FindInferenceService(ctx context.Context, name string, externalId string, parentResourceId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetInferenceServiceByParams(apiutils.StrPtr(name), apiutils.StrPtr(parentResourceId), apiutils.StrPtr(externalId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// FindArtifact - Get an Artifact that matches search parameters.
|
|
func (s *ModelRegistryServiceAPIService) FindArtifact(ctx context.Context, name string, externalId string, parentResourceId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetArtifactByParams(apiutils.StrPtr(name), apiutils.StrPtr(parentResourceId), apiutils.StrPtr(externalId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// FindModelArtifact - Get a ModelArtifact that matches search parameters.
|
|
func (s *ModelRegistryServiceAPIService) FindModelArtifact(ctx context.Context, name string, externalId string, parentResourceId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetModelArtifactByParams(apiutils.StrPtr(name), apiutils.StrPtr(parentResourceId), apiutils.StrPtr(externalId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// FindModelVersion - Get a ModelVersion that matches search parameters.
|
|
func (s *ModelRegistryServiceAPIService) FindModelVersion(ctx context.Context, name string, externalId string, registeredModelId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetModelVersionByParams(apiutils.StrPtr(name), apiutils.StrPtr(registeredModelId), apiutils.StrPtr(externalId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// FindRegisteredModel - Get a RegisteredModel that matches search parameters.
|
|
func (s *ModelRegistryServiceAPIService) FindRegisteredModel(ctx context.Context, name string, externalID string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetRegisteredModelByParams(apiutils.StrPtr(name), apiutils.StrPtr(externalID))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// FindServingEnvironment - Find ServingEnvironment
|
|
func (s *ModelRegistryServiceAPIService) FindServingEnvironment(ctx context.Context, name string, externalID string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetServingEnvironmentByParams(apiutils.StrPtr(name), apiutils.StrPtr(externalID))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetEnvironmentInferenceServices - List All ServingEnvironment's InferenceServices
|
|
func (s *ModelRegistryServiceAPIService) GetEnvironmentInferenceServices(ctx context.Context, servingenvironmentId string, filterQuery string, name string, externalID string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetInferenceServices(listOpts, apiutils.StrPtr(servingenvironmentId), nil)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetInferenceService - Get a InferenceService
|
|
func (s *ModelRegistryServiceAPIService) GetInferenceService(ctx context.Context, inferenceserviceId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetInferenceServiceById(inferenceserviceId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetInferenceServiceModel - Get InferenceService's RegisteredModel
|
|
func (s *ModelRegistryServiceAPIService) GetInferenceServiceModel(ctx context.Context, inferenceserviceId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetRegisteredModelByInferenceService(inferenceserviceId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetInferenceServiceServes - List All InferenceService's ServeModel actions
|
|
func (s *ModelRegistryServiceAPIService) GetInferenceServiceServes(ctx context.Context, inferenceserviceId string, filterQuery string, name string, externalID string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetServeModels(listOpts, apiutils.StrPtr(inferenceserviceId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetInferenceServiceVersion - Get InferenceService's ModelVersion
|
|
func (s *ModelRegistryServiceAPIService) GetInferenceServiceVersion(ctx context.Context, inferenceserviceId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetModelVersionByInferenceService(inferenceserviceId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetInferenceServices - List All InferenceServices
|
|
func (s *ModelRegistryServiceAPIService) GetInferenceServices(ctx context.Context, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetInferenceServices(listOpts, nil, nil)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetArtifact - Get a Artifact
|
|
func (s *ModelRegistryServiceAPIService) GetArtifact(ctx context.Context, artifactId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetArtifactById(artifactId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetArtifacts - List All Artifacts
|
|
func (s *ModelRegistryServiceAPIService) GetArtifacts(ctx context.Context, filterQuery string, artifactType model.ArtifactTypeQueryParam, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetArtifacts(artifactType, listOpts, nil)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetModelArtifact - Get a ModelArtifact
|
|
func (s *ModelRegistryServiceAPIService) GetModelArtifact(ctx context.Context, modelartifactId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetModelArtifactById(modelartifactId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetModelArtifacts - List All ModelArtifacts
|
|
func (s *ModelRegistryServiceAPIService) GetModelArtifacts(ctx context.Context, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetModelArtifacts(listOpts, nil)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetModelVersion - Get a ModelVersion
|
|
func (s *ModelRegistryServiceAPIService) GetModelVersion(ctx context.Context, modelversionId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetModelVersionById(modelversionId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetModelVersionArtifacts - List All ModelVersion's artifacts
|
|
func (s *ModelRegistryServiceAPIService) GetModelVersionArtifacts(ctx context.Context, modelversionId string,
|
|
filterQuery string, name string, externalID string, artifactType model.ArtifactTypeQueryParam, pageSize string,
|
|
orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
|
|
// Build combined filter query from filterQuery, name, and externalID parameters
|
|
combinedFilterQuery := buildCombinedFilterQuery(filterQuery, name, externalID)
|
|
|
|
listOpts, err := s.buildListOption(combinedFilterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetArtifacts(artifactType, listOpts, apiutils.StrPtr(modelversionId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// buildCombinedFilterQuery combines filterQuery with name and externalID parameters
|
|
func buildCombinedFilterQuery(filterQuery, name, externalID string) string {
|
|
var conditions []string
|
|
|
|
// Add existing filter query if provided
|
|
if filterQuery != "" {
|
|
conditions = append(conditions, "("+filterQuery+")")
|
|
}
|
|
|
|
// Add name or externalID filter (exclusive)
|
|
if name != "" {
|
|
// Escape single quotes in the name by doubling them
|
|
escapedName := strings.ReplaceAll(name, "'", "''")
|
|
conditions = append(conditions, "name = '"+escapedName+"'")
|
|
} else if externalID != "" {
|
|
// Escape single quotes in the externalID by doubling them
|
|
escapedExternalID := strings.ReplaceAll(externalID, "'", "''")
|
|
conditions = append(conditions, "externalId = '"+escapedExternalID+"'")
|
|
}
|
|
|
|
// Combine all conditions with AND
|
|
if len(conditions) == 0 {
|
|
return ""
|
|
}
|
|
|
|
if len(conditions) == 1 {
|
|
return conditions[0]
|
|
}
|
|
|
|
return conditions[0] + " AND " + conditions[1]
|
|
}
|
|
|
|
// GetModelVersions - List All ModelVersions
|
|
func (s *ModelRegistryServiceAPIService) GetModelVersions(ctx context.Context, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetModelVersions(listOpts, nil)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetRegisteredModel - Get a RegisteredModel
|
|
func (s *ModelRegistryServiceAPIService) GetRegisteredModel(ctx context.Context, registeredmodelId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetRegisteredModelById(registeredmodelId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetRegisteredModelVersions - List All RegisteredModel's ModelVersions
|
|
func (s *ModelRegistryServiceAPIService) GetRegisteredModelVersions(ctx context.Context, registeredmodelId string, name string, externalID string, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
// Build combined filter query from filterQuery, name, and externalID parameters
|
|
combinedFilterQuery := buildCombinedFilterQuery(filterQuery, name, externalID)
|
|
|
|
listOpts, err := s.buildListOption(combinedFilterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetModelVersions(listOpts, apiutils.StrPtr(registeredmodelId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetRegisteredModels - List All RegisteredModels
|
|
func (s *ModelRegistryServiceAPIService) GetRegisteredModels(ctx context.Context, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetRegisteredModels(listOpts)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetServingEnvironment - Get a ServingEnvironment
|
|
func (s *ModelRegistryServiceAPIService) GetServingEnvironment(ctx context.Context, servingenvironmentId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetServingEnvironmentById(servingenvironmentId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetServingEnvironments - List All ServingEnvironments
|
|
func (s *ModelRegistryServiceAPIService) GetServingEnvironments(ctx context.Context, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetServingEnvironments(listOpts)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpdateInferenceService - Update a InferenceService
|
|
func (s *ModelRegistryServiceAPIService) UpdateInferenceService(ctx context.Context, inferenceserviceId string, inferenceServiceUpdate model.InferenceServiceUpdate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertInferenceServiceUpdate(&inferenceServiceUpdate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
entity.Id = &inferenceserviceId
|
|
existing, err := s.coreApi.GetInferenceServiceById(inferenceserviceId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
update, err := s.reconciler.UpdateExistingInferenceService(converter.NewOpenapiUpdateWrapper(existing, entity))
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
result, err := s.coreApi.UpsertInferenceService(&update)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpdateArtifact - Update a Artifact
|
|
func (s *ModelRegistryServiceAPIService) UpdateArtifact(ctx context.Context, artifactId string, artifactUpdate model.ArtifactUpdate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertArtifactUpdate(&artifactUpdate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
if artifactUpdate.DocArtifactUpdate != nil {
|
|
entity.DocArtifact.Id = &artifactId
|
|
}
|
|
if artifactUpdate.ModelArtifactUpdate != nil {
|
|
entity.ModelArtifact.Id = &artifactId
|
|
}
|
|
existing, err := s.coreApi.GetArtifactById(artifactId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
update, err := converter.UpdateExistingArtifact(s.reconciler, converter.NewOpenapiUpdateWrapper(existing, entity))
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
result, err := s.coreApi.UpsertArtifact(&update)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpdateModelArtifact - Update a ModelArtifact
|
|
func (s *ModelRegistryServiceAPIService) UpdateModelArtifact(ctx context.Context, modelartifactId string, modelArtifactUpdate model.ModelArtifactUpdate) (ImplResponse, error) {
|
|
modelArtifact, err := s.converter.ConvertModelArtifactUpdate(&modelArtifactUpdate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
modelArtifact.Id = &modelartifactId
|
|
existing, err := s.coreApi.GetModelArtifactById(modelartifactId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
update, err := s.reconciler.UpdateExistingModelArtifact(converter.NewOpenapiUpdateWrapper(existing, modelArtifact))
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
result, err := s.coreApi.UpsertModelArtifact(&update)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpdateModelVersion - Update a ModelVersion
|
|
func (s *ModelRegistryServiceAPIService) UpdateModelVersion(ctx context.Context, modelversionId string, modelVersionUpdate model.ModelVersionUpdate) (ImplResponse, error) {
|
|
modelVersion, err := s.converter.ConvertModelVersionUpdate(&modelVersionUpdate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
modelVersion.Id = &modelversionId
|
|
existing, err := s.coreApi.GetModelVersionById(modelversionId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
update, err := s.reconciler.UpdateExistingModelVersion(converter.NewOpenapiUpdateWrapper(existing, modelVersion))
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
result, err := s.coreApi.UpsertModelVersion(&update, nil)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpdateRegisteredModel - Update a RegisteredModel
|
|
func (s *ModelRegistryServiceAPIService) UpdateRegisteredModel(ctx context.Context, registeredmodelId string, registeredModelUpdate model.RegisteredModelUpdate) (ImplResponse, error) {
|
|
registeredModel, err := s.converter.ConvertRegisteredModelUpdate(®isteredModelUpdate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
registeredModel.Id = ®isteredmodelId
|
|
existing, err := s.coreApi.GetRegisteredModelById(registeredmodelId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
update, err := s.reconciler.UpdateExistingRegisteredModel(converter.NewOpenapiUpdateWrapper(existing, registeredModel))
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
result, err := s.coreApi.UpsertRegisteredModel(&update)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpdateServingEnvironment - Update a ServingEnvironment
|
|
func (s *ModelRegistryServiceAPIService) UpdateServingEnvironment(ctx context.Context, servingenvironmentId string, servingEnvironmentUpdate model.ServingEnvironmentUpdate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertServingEnvironmentUpdate(&servingEnvironmentUpdate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
entity.Id = &servingenvironmentId
|
|
existing, err := s.coreApi.GetServingEnvironmentById(servingenvironmentId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
update, err := s.reconciler.UpdateExistingServingEnvironment(converter.NewOpenapiUpdateWrapper(existing, entity))
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
result, err := s.coreApi.UpsertServingEnvironment(&update)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// CreateExperiment - Create an Experiment
|
|
func (s *ModelRegistryServiceAPIService) CreateExperiment(ctx context.Context, experimentCreate model.ExperimentCreate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertExperimentCreate(&experimentCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertExperiment(entity)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateExperimentExperimentRun - Create an ExperimentRun in Experiment
|
|
func (s *ModelRegistryServiceAPIService) CreateExperimentExperimentRun(ctx context.Context, experimentId string, experimentRun model.ExperimentRun) (ImplResponse, error) {
|
|
result, err := s.coreApi.UpsertExperimentRun(&experimentRun, apiutils.StrPtr(experimentId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// CreateExperimentRun - Create an ExperimentRun
|
|
func (s *ModelRegistryServiceAPIService) CreateExperimentRun(ctx context.Context, experimentRunCreate model.ExperimentRunCreate) (ImplResponse, error) {
|
|
experimentRun, err := s.converter.ConvertExperimentRunCreate(&experimentRunCreate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
|
|
result, err := s.coreApi.UpsertExperimentRun(experimentRun, &experimentRunCreate.ExperimentId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
|
|
// FindExperiment - Get an Experiment that matches search parameters
|
|
func (s *ModelRegistryServiceAPIService) FindExperiment(ctx context.Context, name string, externalId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetExperimentByParams(apiutils.StrPtr(name), apiutils.StrPtr(externalId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// FindExperimentRun - Get an ExperimentRun that matches search parameters
|
|
func (s *ModelRegistryServiceAPIService) FindExperimentRun(ctx context.Context, name string, externalId string, parentResourceId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetExperimentRunByParams(apiutils.StrPtr(name), apiutils.StrPtr(parentResourceId), apiutils.StrPtr(externalId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetExperiment - Get an Experiment
|
|
func (s *ModelRegistryServiceAPIService) GetExperiment(ctx context.Context, experimentId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetExperimentById(experimentId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetExperimentExperimentRuns - List All Experiment's ExperimentRuns
|
|
func (s *ModelRegistryServiceAPIService) GetExperimentExperimentRuns(ctx context.Context, experimentId string, name string, externalId string, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetExperimentRuns(listOpts, apiutils.StrPtr(experimentId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetExperimentRun - Get an ExperimentRun
|
|
func (s *ModelRegistryServiceAPIService) GetExperimentRun(ctx context.Context, experimentrunId string) (ImplResponse, error) {
|
|
result, err := s.coreApi.GetExperimentRunById(experimentrunId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetExperimentRunArtifacts - List all artifacts associated with the ExperimentRun
|
|
func (s *ModelRegistryServiceAPIService) GetExperimentRunArtifacts(ctx context.Context, experimentrunId string,
|
|
filterQuery string, name string, externalId string, artifactType model.ArtifactTypeQueryParam, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetExperimentRunArtifacts(artifactType, listOpts, apiutils.StrPtr(experimentrunId))
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetExperimentRuns - List All ExperimentRuns
|
|
func (s *ModelRegistryServiceAPIService) GetExperimentRuns(ctx context.Context, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetExperimentRuns(listOpts, nil)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetExperiments - List All Experiments
|
|
func (s *ModelRegistryServiceAPIService) GetExperiments(ctx context.Context, filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
result, err := s.coreApi.GetExperiments(listOpts)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpdateExperiment - Update an Experiment
|
|
func (s *ModelRegistryServiceAPIService) UpdateExperiment(ctx context.Context, experimentId string, experimentUpdate model.ExperimentUpdate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertExperimentUpdate(&experimentUpdate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
entity.Id = &experimentId
|
|
existing, err := s.coreApi.GetExperimentById(experimentId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
update, err := s.reconciler.UpdateExistingExperiment(converter.NewOpenapiUpdateWrapper(existing, entity))
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
result, err := s.coreApi.UpsertExperiment(&update)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpdateExperimentRun - Update an ExperimentRun
|
|
func (s *ModelRegistryServiceAPIService) UpdateExperimentRun(ctx context.Context, experimentrunId string, experimentRunUpdate model.ExperimentRunUpdate) (ImplResponse, error) {
|
|
entity, err := s.converter.ConvertExperimentRunUpdate(&experimentRunUpdate)
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
entity.Id = &experimentrunId
|
|
existing, err := s.coreApi.GetExperimentRunById(experimentrunId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
update, err := s.reconciler.UpdateExistingExperimentRun(converter.NewOpenapiUpdateWrapper(existing, entity))
|
|
if err != nil {
|
|
return ErrorResponse(http.StatusBadRequest, err), err
|
|
}
|
|
// Extract experiment ID from existing run for the upsert call
|
|
result, err := s.coreApi.UpsertExperimentRun(&update, &existing.ExperimentId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// UpsertExperimentRunArtifact - Upsert an Artifact in an ExperimentRun
|
|
func (s *ModelRegistryServiceAPIService) UpsertExperimentRunArtifact(ctx context.Context, experimentrunId string, artifact model.Artifact) (ImplResponse, error) {
|
|
creating := (artifact.DocArtifact != nil && artifact.DocArtifact.Id == nil) || (artifact.ModelArtifact != nil && artifact.ModelArtifact.Id == nil)
|
|
|
|
result, err := s.coreApi.UpsertExperimentRunArtifact(&artifact, experimentrunId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
if creating {
|
|
return Response(http.StatusCreated, result), nil
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
// GetExperimentRunMetricHistory - Get metric history for an ExperimentRun
|
|
func (s *ModelRegistryServiceAPIService) GetExperimentRunMetricHistory(ctx context.Context, experimentrunId string,
|
|
filterQuery string, name string, stepIds string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
return s.getMetricHistoryHelper(ctx, apiutils.StrPtr(experimentrunId), filterQuery, name, stepIds, pageSize, orderBy, sortOrder, nextPageToken)
|
|
}
|
|
|
|
// GetExperimentRunsMetricHistory - Get metric history for multiple ExperimentRuns
|
|
func (s *ModelRegistryServiceAPIService) GetExperimentRunsMetricHistory(ctx context.Context,
|
|
filterQuery string, name string, stepIds string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
// Pass nil for experimentRunId to get metrics for all experiment runs
|
|
return s.getMetricHistoryHelper(ctx, nil, filterQuery, name, stepIds, pageSize, orderBy, sortOrder, nextPageToken)
|
|
}
|
|
|
|
// getMetricHistoryHelper handles the common logic for getting metric history
|
|
func (s *ModelRegistryServiceAPIService) getMetricHistoryHelper(ctx context.Context, experimentRunId *string,
|
|
filterQuery string, name string, stepIds string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (ImplResponse, error) {
|
|
listOpts, err := s.buildListOption(filterQuery, pageSize, orderBy, sortOrder, nextPageToken)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
|
|
var namePtr *string
|
|
if name != "" {
|
|
namePtr = &name
|
|
}
|
|
|
|
var stepIdsPtr *string
|
|
if stepIds != "" {
|
|
stepIdsPtr = &stepIds
|
|
}
|
|
|
|
result, err := s.coreApi.GetExperimentRunMetricHistory(namePtr, stepIdsPtr, listOpts, experimentRunId)
|
|
if err != nil {
|
|
return ErrorResponse(api.ErrToStatus(err), err), err
|
|
}
|
|
return Response(http.StatusOK, result), nil
|
|
}
|
|
|
|
func (s *ModelRegistryServiceAPIService) buildListOption(filterQuery string, pageSize string, orderBy model.OrderByField, sortOrder model.SortOrder, nextPageToken string) (api.ListOptions, error) {
|
|
var filterQueryPtr *string
|
|
if filterQuery != "" {
|
|
filterQueryPtr = &filterQuery
|
|
}
|
|
var pageSizeInt32 *int32
|
|
if pageSize != "" {
|
|
conv, err := converter.StringToInt32(pageSize)
|
|
if err != nil {
|
|
return api.ListOptions{}, fmt.Errorf("%v: %w", err, api.ErrBadRequest)
|
|
}
|
|
pageSizeInt32 = &conv
|
|
}
|
|
var orderByString *string
|
|
if orderBy != "" {
|
|
orderByString = (*string)(&orderBy)
|
|
}
|
|
var sortOrderString *string
|
|
if sortOrder != "" {
|
|
sortOrderString = (*string)(&sortOrder)
|
|
}
|
|
var nextPageTokenParam *string
|
|
if nextPageToken != "" {
|
|
nextPageTokenParam = &nextPageToken
|
|
}
|
|
return api.ListOptions{
|
|
FilterQuery: filterQueryPtr,
|
|
PageSize: pageSizeInt32,
|
|
OrderBy: orderByString,
|
|
SortOrder: sortOrderString,
|
|
NextPageToken: nextPageTokenParam,
|
|
}, nil
|
|
}
|