From c91aba6b143b7bfa9709a9bd3815b15c4bfc4cca Mon Sep 17 00:00:00 2001 From: Paul Boyd Date: Wed, 15 Oct 2025 06:29:53 -0400 Subject: [PATCH] fix(catalog): regenerate files And fix badly generated openapi code. Signed-off-by: Paul Boyd --- catalog/internal/server/openapi/api.go | 17 +- .../openapi/api_model_catalog_service.go | 20 +- catalog/internal/server/openapi/helpers.go | 18 +- catalog/internal/server/openapi/routers.go | 8 +- .../internal/server/openapi/type_asserts.go | 24 - .../server/openapi/type_asserts_overrides.go | 19 + catalog/scripts/gen_type_asserts.sh | 4 +- .../embedmd_openapi_converter.gen.go | 398 ++++ .../generated/openapi_converter.gen.go | 1735 +++++++++++++++++ .../openapi_embedmd_converter.gen.go | 530 +++++ .../generated/openapi_reconciler.gen.go | 1177 +++++++++++ 11 files changed, 3899 insertions(+), 51 deletions(-) create mode 100644 internal/converter/generated/embedmd_openapi_converter.gen.go create mode 100644 internal/converter/generated/openapi_converter.gen.go create mode 100644 internal/converter/generated/openapi_embedmd_converter.gen.go create mode 100644 internal/converter/generated/openapi_reconciler.gen.go diff --git a/catalog/internal/server/openapi/api.go b/catalog/internal/server/openapi/api.go index caec09622..fc7252e8e 100644 --- a/catalog/internal/server/openapi/api.go +++ b/catalog/internal/server/openapi/api.go @@ -17,12 +17,10 @@ import ( model "github.com/kubeflow/model-registry/catalog/pkg/openapi" ) - - // ModelCatalogServiceAPIRouter defines the required methods for binding the api requests to a responses for the ModelCatalogServiceAPI // The ModelCatalogServiceAPIRouter implementation should parse necessary information from the http request, // pass the data to a ModelCatalogServiceAPIServicer to perform the required actions, then write the service results to the http response. -type ModelCatalogServiceAPIRouter interface { +type ModelCatalogServiceAPIRouter interface { FindModels(http.ResponseWriter, *http.Request) FindModelsFilterOptions(http.ResponseWriter, *http.Request) FindSources(http.ResponseWriter, *http.Request) @@ -30,15 +28,14 @@ type ModelCatalogServiceAPIRouter interface { GetModel(http.ResponseWriter, *http.Request) } - // ModelCatalogServiceAPIServicer defines the api actions for the ModelCatalogServiceAPI service // This interface intended to stay up to date with the openapi yaml used to generate it, // while the service implementation can be ignored with the .openapi-generator-ignore file // and updated with the logic required for the API. -type ModelCatalogServiceAPIServicer interface { - FindModels(context.Context, []string, string, string, string, string, model.OrderByField, model.SortOrder, string) (ImplResponse, error) - FindModelsFilterOptions(context.Context) (ImplResponse, error) - FindSources(context.Context, string, string, model.OrderByField, model.SortOrder, string) (ImplResponse, error) - GetAllModelArtifacts(context.Context, string, string, string, model.OrderByField, model.SortOrder, string, string) (ImplResponse, error) - GetModel(context.Context, string, string) (ImplResponse, error) +type ModelCatalogServiceAPIServicer interface { + FindModels(context.Context, []string, string, string, string, string, model.OrderByField, model.SortOrder, string) (ImplResponse, error) + FindModelsFilterOptions(context.Context) (ImplResponse, error) + FindSources(context.Context, string, string, model.OrderByField, model.SortOrder, string) (ImplResponse, error) + GetAllModelArtifacts(context.Context, string, string, string, model.OrderByField, model.SortOrder, string, string) (ImplResponse, error) + GetModel(context.Context, string, string) (ImplResponse, error) } diff --git a/catalog/internal/server/openapi/api_model_catalog_service.go b/catalog/internal/server/openapi/api_model_catalog_service.go index 7925b8cc4..152843e24 100644 --- a/catalog/internal/server/openapi/api_model_catalog_service.go +++ b/catalog/internal/server/openapi/api_model_catalog_service.go @@ -11,7 +11,6 @@ package openapi import ( - "net/http" "strings" @@ -75,7 +74,7 @@ func (c *ModelCatalogServiceAPIController) Routes() Routes { }, "GetModel": Route{ strings.ToUpper("Get"), - "/api/model_catalog/v1alpha1/sources/{source_id}/models/{model_name+}", + "/api/model_catalog/v1alpha1/sources/{source_id}/models/*", c.GetModel, }, } @@ -155,7 +154,22 @@ func (c *ModelCatalogServiceAPIController) GetAllModelArtifacts(w http.ResponseW // GetModel - Get a `CatalogModel`. func (c *ModelCatalogServiceAPIController) GetModel(w http.ResponseWriter, r *http.Request) { sourceIdParam := chi.URLParam(r, "source_id") - modelNameParam := chi.URLParam(r, "model_name+") + modelNameParam := chi.URLParam(r, "*") + + // Special handling for getModel to delegate /artifacts requests to getAllModelArtifacts + // The wildcard /* pattern catches /artifacts requests, but we want those to go to GetAllModelArtifacts + if strings.HasSuffix(r.URL.Path, "/artifacts") { + // Extract the model name by removing the /artifacts suffix + modelName := strings.TrimSuffix(modelNameParam, "/artifacts") + + // Add the model_name parameter to the route context so GetAllModelArtifacts can access it + chi.RouteContext(r.Context()).URLParams.Add("model_name", modelName) + + // Call the GetAllModelArtifacts handler directly + c.GetAllModelArtifacts(w, r) + return + } + result, err := c.service.GetModel(r.Context(), sourceIdParam, modelNameParam) // If an error occurred, encode the error with the status code if err != nil { diff --git a/catalog/internal/server/openapi/helpers.go b/catalog/internal/server/openapi/helpers.go index d0e759ffa..b6bff9d4a 100644 --- a/catalog/internal/server/openapi/helpers.go +++ b/catalog/internal/server/openapi/helpers.go @@ -11,28 +11,28 @@ package openapi import ( + "net/http" "reflect" - "net/http" model "github.com/kubeflow/model-registry/pkg/openapi" ) // Response return a ImplResponse struct filled func Response(code int, body interface{}) ImplResponse { - return ImplResponse { + return ImplResponse{ Code: code, Body: body, } } func ErrorResponse(code int, err error) ImplResponse { - return ImplResponse{ - Code: code, - Body: model.Error{ - Code: http.StatusText(code), - Message: err.Error(), - }, - } + return ImplResponse{ + Code: code, + Body: model.Error{ + Code: http.StatusText(code), + Message: err.Error(), + }, + } } // IsZeroValue checks if the val is the zero-ed value. diff --git a/catalog/internal/server/openapi/routers.go b/catalog/internal/server/openapi/routers.go index 92263bed7..f2c4ceec3 100644 --- a/catalog/internal/server/openapi/routers.go +++ b/catalog/internal/server/openapi/routers.go @@ -30,8 +30,8 @@ import ( // A Route defines the parameters for an api endpoint type Route struct { - Method string - Pattern string + Method string + Pattern string HandlerFunc http.HandlerFunc } @@ -80,8 +80,8 @@ func EncodeJSONResponse(i interface{}, status *int, w http.ResponseWriter) { if i != nil { if err := json.NewEncoder(w).Encode(i); err != nil { - // FIXME: is it too late to inform the client of an error at this point?? - glog.Errorf("error encoding JSON response: %v", err) + // FIXME: is it too late to inform the client of an error at this point?? + glog.Errorf("error encoding JSON response: %v", err) } } } diff --git a/catalog/internal/server/openapi/type_asserts.go b/catalog/internal/server/openapi/type_asserts.go index 6dac85b9c..5fe02de68 100644 --- a/catalog/internal/server/openapi/type_asserts.go +++ b/catalog/internal/server/openapi/type_asserts.go @@ -257,11 +257,6 @@ func AssertErrorRequired(obj model.Error) error { return nil } -// AssertFilterOptionConstraints checks if the values respects the defined constraints -func AssertFilterOptionConstraints(obj model.FilterOption) error { - return nil -} - // AssertFilterOptionRangeConstraints checks if the values respects the defined constraints func AssertFilterOptionRangeConstraints(obj model.FilterOptionRange) error { return nil @@ -272,25 +267,6 @@ func AssertFilterOptionRangeRequired(obj model.FilterOptionRange) error { return nil } -// AssertFilterOptionRequired checks if the required fields are not zero-ed -func AssertFilterOptionRequired(obj model.FilterOption) error { - elements := map[string]interface{}{ - "type": obj.Type, - } - for name, el := range elements { - if isZero := IsZeroValue(el); isZero { - return &RequiredError{Field: name} - } - } - - if obj.Range != nil { - if err := AssertFilterOptionRangeRequired(*obj.Range); err != nil { - return err - } - } - return nil -} - // AssertFilterOptionsListConstraints checks if the values respects the defined constraints func AssertFilterOptionsListConstraints(obj model.FilterOptionsList) error { return nil diff --git a/catalog/internal/server/openapi/type_asserts_overrides.go b/catalog/internal/server/openapi/type_asserts_overrides.go index 4e950e745..40b4a6d47 100644 --- a/catalog/internal/server/openapi/type_asserts_overrides.go +++ b/catalog/internal/server/openapi/type_asserts_overrides.go @@ -10,3 +10,22 @@ func AssertCatalogArtifactRequired(obj model.CatalogArtifact) error { // checks the fields from CatalogModelArtifact, which doesn't compile. return nil } + +// AssertFilterOptionRequired checks if the required fields are not zero-ed +func AssertFilterOptionRequired(obj model.FilterOption) error { + elements := map[string]interface{}{ + "type": obj.Type, + } + for name, el := range elements { + if isZero := IsZeroValue(el); isZero { + return &RequiredError{Field: name} + } + } + + if obj.Range != nil { + if err := AssertFilterOptionRangeRequired(*obj.Range); err != nil { + return err + } + } + return nil +} diff --git a/catalog/scripts/gen_type_asserts.sh b/catalog/scripts/gen_type_asserts.sh index 900240e58..e5ed01f7e 100755 --- a/catalog/scripts/gen_type_asserts.sh +++ b/catalog/scripts/gen_type_asserts.sh @@ -7,7 +7,9 @@ ASSERT_FILE_PATH="$1/type_asserts.go" PROJECT_ROOT=$(realpath "$(dirname "$0")"/..) # These files generate with incorrect logic: -rm -f "$1/model_metadata_value.go" "$1/model_catalog_artifact.go" +rm -f "$1/model_metadata_value.go" \ + "$1/model_catalog_artifact.go" \ + "$1/model_filter_option.go" python3 "${PROJECT_ROOT}/scripts/gen_type_asserts.py" $1 >"$ASSERT_FILE_PATH" diff --git a/internal/converter/generated/embedmd_openapi_converter.gen.go b/internal/converter/generated/embedmd_openapi_converter.gen.go new file mode 100644 index 000000000..c3eacfe23 --- /dev/null +++ b/internal/converter/generated/embedmd_openapi_converter.gen.go @@ -0,0 +1,398 @@ +// Code generated by github.com/jmattheis/goverter, DO NOT EDIT. +//go:build !goverter + +package generated + +import ( + "fmt" + converter "github.com/kubeflow/model-registry/internal/converter" + models "github.com/kubeflow/model-registry/internal/db/models" + openapi "github.com/kubeflow/model-registry/pkg/openapi" +) + +type EmbedMDToOpenAPIConverterImpl struct{} + +func (c *EmbedMDToOpenAPIConverterImpl) ConvertDataSet(source *models.BaseEntity[models.DataSetAttributes]) (*openapi.DataSet, error) { + var pOpenapiDataSet *openapi.DataSet + if source != nil { + var openapiDataSet openapi.DataSet + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiDataSet.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiDataSet.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiDataSet.ExternalId = converter.MapEmbedMDExternalIDDataSet((*source).Attributes) + openapiDataSet.Name = converter.MapEmbedMDNameDataSet((*source).Attributes) + openapiDataSet.Id = converter.Int32ToString((*source).ID) + openapiDataSet.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochDataSet((*source).Attributes) + openapiDataSet.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochDataSet((*source).Attributes) + openapiDataSet.ExperimentId = converter.MapEmbedMDExperimentId((*source).CustomProperties) + openapiDataSet.ExperimentRunId = converter.MapEmbedMDExperimentRunId((*source).CustomProperties) + openapiDataSet.ArtifactType = converter.MapEmbedMDArtifactTypeDataSet((*source).Attributes) + openapiDataSet.Digest = converter.MapEmbedMDPropertyDigest((*source).Properties) + openapiDataSet.SourceType = converter.MapEmbedMDPropertySourceType((*source).Properties) + openapiDataSet.Source = converter.MapEmbedMDPropertySource((*source).Properties) + openapiDataSet.Schema = converter.MapEmbedMDPropertySchema((*source).Properties) + openapiDataSet.Profile = converter.MapEmbedMDPropertyProfile((*source).Properties) + openapiDataSet.Uri = converter.MapEmbedMDURIDataSet((*source).Attributes) + pOpenapiArtifactState, err := converter.MapEmbedMDStateDataSet((*source).Attributes) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiDataSet.State = pOpenapiArtifactState + pOpenapiDataSet = &openapiDataSet + } + return pOpenapiDataSet, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertDocArtifact(source *models.BaseEntity[models.DocArtifactAttributes]) (*openapi.DocArtifact, error) { + var pOpenapiDocArtifact *openapi.DocArtifact + if source != nil { + var openapiDocArtifact openapi.DocArtifact + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiDocArtifact.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiDocArtifact.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiDocArtifact.ExternalId = converter.MapEmbedMDExternalIDDocArtifact((*source).Attributes) + openapiDocArtifact.Name = converter.MapEmbedMDNameDocArtifact((*source).Attributes) + openapiDocArtifact.Id = converter.Int32ToString((*source).ID) + openapiDocArtifact.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochDocArtifact((*source).Attributes) + openapiDocArtifact.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochDocArtifact((*source).Attributes) + openapiDocArtifact.ExperimentId = converter.MapEmbedMDExperimentId((*source).CustomProperties) + openapiDocArtifact.ExperimentRunId = converter.MapEmbedMDExperimentRunId((*source).CustomProperties) + openapiDocArtifact.ArtifactType = converter.MapEmbedMDArtifactTypeDocArtifact((*source).Attributes) + openapiDocArtifact.Uri = converter.MapEmbedMDURIDocArtifact((*source).Attributes) + pOpenapiArtifactState, err := converter.MapEmbedMDStateDocArtifact((*source).Attributes) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiDocArtifact.State = pOpenapiArtifactState + pOpenapiDocArtifact = &openapiDocArtifact + } + return pOpenapiDocArtifact, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertExperiment(source *models.BaseEntity[models.ExperimentAttributes]) (*openapi.Experiment, error) { + var pOpenapiExperiment *openapi.Experiment + if source != nil { + var openapiExperiment openapi.Experiment + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiExperiment.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiExperiment.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiExperiment.ExternalId = converter.MapEmbedMDExternalIDExperiment((*source).Attributes) + openapiExperiment.Name = converter.MapEmbedMDNameExperiment((*source).Attributes) + openapiExperiment.Id = converter.Int32ToString((*source).ID) + openapiExperiment.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochExperiment((*source).Attributes) + openapiExperiment.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochExperiment((*source).Attributes) + openapiExperiment.Owner = converter.MapEmbedMDOwner((*source).Properties) + pOpenapiExperimentState, err := converter.MapEmbedMDStateExperiment((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiExperiment.State = pOpenapiExperimentState + pOpenapiExperiment = &openapiExperiment + } + return pOpenapiExperiment, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertExperimentRun(source *models.BaseEntity[models.ExperimentRunAttributes]) (*openapi.ExperimentRun, error) { + var pOpenapiExperimentRun *openapi.ExperimentRun + if source != nil { + var openapiExperimentRun openapi.ExperimentRun + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiExperimentRun.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiExperimentRun.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiExperimentRun.ExternalId = converter.MapEmbedMDExternalIDExperimentRun((*source).Attributes) + openapiExperimentRun.Name = converter.MapEmbedMDNameExperimentRun((*source).Attributes) + openapiExperimentRun.EndTimeSinceEpoch = converter.MapEmbedMDPropertyEndTimeSinceEpochExperimentRun((*source).Properties) + pOpenapiExperimentRunStatus, err := converter.MapEmbedMDPropertyStatusExperimentRun((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field Status: %w", err) + } + openapiExperimentRun.Status = pOpenapiExperimentRunStatus + pOpenapiExperimentRunState, err := converter.MapEmbedMDStateExperimentRun((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiExperimentRun.State = pOpenapiExperimentRunState + openapiExperimentRun.Owner = converter.MapEmbedMDOwner((*source).Properties) + xstring, err := converter.MapEmbedMDPropertyExperimentIdExperimentRun((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field ExperimentId: %w", err) + } + openapiExperimentRun.ExperimentId = xstring + openapiExperimentRun.StartTimeSinceEpoch = converter.MapEmbedMDPropertyStartTimeSinceEpochExperimentRun((*source).Properties) + openapiExperimentRun.Id = converter.Int32ToString((*source).ID) + openapiExperimentRun.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochExperimentRun((*source).Attributes) + openapiExperimentRun.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochExperimentRun((*source).Attributes) + pOpenapiExperimentRun = &openapiExperimentRun + } + return pOpenapiExperimentRun, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertInferenceService(source *models.BaseEntity[models.InferenceServiceAttributes]) (*openapi.InferenceService, error) { + var pOpenapiInferenceService *openapi.InferenceService + if source != nil { + var openapiInferenceService openapi.InferenceService + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiInferenceService.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiInferenceService.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiInferenceService.ExternalId = converter.MapEmbedMDExternalIDInferenceService((*source).Attributes) + openapiInferenceService.Name = converter.MapEmbedMDNameInferenceService((*source).Attributes) + openapiInferenceService.Id = converter.Int32ToString((*source).ID) + openapiInferenceService.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochInferenceService((*source).Attributes) + openapiInferenceService.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochInferenceService((*source).Attributes) + openapiInferenceService.ModelVersionId = converter.MapEmbedMDPropertyModelVersionId((*source).Properties) + openapiInferenceService.Runtime = converter.MapEmbedMDPropertyRuntime((*source).Properties) + pOpenapiInferenceServiceState, err := converter.MapEmbedMDPropertyDesiredStateInferenceService((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field DesiredState: %w", err) + } + openapiInferenceService.DesiredState = pOpenapiInferenceServiceState + openapiInferenceService.RegisteredModelId = converter.MapEmbedMDPropertyRegisteredModelId((*source).Properties) + openapiInferenceService.ServingEnvironmentId = converter.MapEmbedMDPropertyServingEnvironmentId((*source).Properties) + pOpenapiInferenceService = &openapiInferenceService + } + return pOpenapiInferenceService, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertMetric(source *models.BaseEntity[models.MetricAttributes]) (*openapi.Metric, error) { + var pOpenapiMetric *openapi.Metric + if source != nil { + var openapiMetric openapi.Metric + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiMetric.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiMetric.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiMetric.ExternalId = converter.MapEmbedMDExternalIDMetric((*source).Attributes) + openapiMetric.Name = converter.MapEmbedMDNameMetric((*source).Attributes) + openapiMetric.Id = converter.Int32ToString((*source).ID) + openapiMetric.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochMetric((*source).Attributes) + openapiMetric.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochMetric((*source).Attributes) + openapiMetric.ExperimentId = converter.MapEmbedMDExperimentId((*source).CustomProperties) + openapiMetric.ExperimentRunId = converter.MapEmbedMDExperimentRunId((*source).CustomProperties) + openapiMetric.ArtifactType = converter.MapEmbedMDArtifactTypeMetric((*source).Attributes) + openapiMetric.Value = converter.MapEmbedMDPropertyValueMetric((*source).Properties) + openapiMetric.Timestamp = converter.MapEmbedMDPropertyTimestampMetric((*source).Properties) + openapiMetric.Step = converter.MapEmbedMDPropertyStepMetric((*source).Properties) + pOpenapiArtifactState, err := converter.MapEmbedMDStateMetric((*source).Attributes) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiMetric.State = pOpenapiArtifactState + pOpenapiMetric = &openapiMetric + } + return pOpenapiMetric, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertModelArtifact(source *models.BaseEntity[models.ModelArtifactAttributes]) (*openapi.ModelArtifact, error) { + var pOpenapiModelArtifact *openapi.ModelArtifact + if source != nil { + var openapiModelArtifact openapi.ModelArtifact + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiModelArtifact.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiModelArtifact.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiModelArtifact.ExternalId = converter.MapEmbedMDExternalIDModelArtifact((*source).Attributes) + openapiModelArtifact.Name = converter.MapEmbedMDNameModelArtifact((*source).Attributes) + openapiModelArtifact.Id = converter.Int32ToString((*source).ID) + openapiModelArtifact.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochModelArtifact((*source).Attributes) + openapiModelArtifact.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochModelArtifact((*source).Attributes) + openapiModelArtifact.ExperimentId = converter.MapEmbedMDExperimentId((*source).CustomProperties) + openapiModelArtifact.ExperimentRunId = converter.MapEmbedMDExperimentRunId((*source).CustomProperties) + openapiModelArtifact.ArtifactType = converter.MapEmbedMDArtifactTypeModelArtifact((*source).Attributes) + openapiModelArtifact.ModelFormatName = converter.MapEmbedMDPropertyModelFormatName((*source).Properties) + openapiModelArtifact.StorageKey = converter.MapEmbedMDPropertyStorageKey((*source).Properties) + openapiModelArtifact.StoragePath = converter.MapEmbedMDPropertyStoragePath((*source).Properties) + openapiModelArtifact.ModelFormatVersion = converter.MapEmbedMDPropertyModelFormatVersion((*source).Properties) + openapiModelArtifact.ServiceAccountName = converter.MapEmbedMDPropertyServiceAccountName((*source).Properties) + openapiModelArtifact.ModelSourceKind = converter.MapEmbedMDPropertyModelSourceKind((*source).Properties) + openapiModelArtifact.ModelSourceClass = converter.MapEmbedMDPropertyModelSourceClass((*source).Properties) + openapiModelArtifact.ModelSourceGroup = converter.MapEmbedMDPropertyModelSourceGroup((*source).Properties) + openapiModelArtifact.ModelSourceId = converter.MapEmbedMDPropertyModelSourceId((*source).Properties) + openapiModelArtifact.ModelSourceName = converter.MapEmbedMDPropertyModelSourceName((*source).Properties) + openapiModelArtifact.Uri = converter.MapEmbedMDURIModelArtifact((*source).Attributes) + pOpenapiArtifactState, err := converter.MapEmbedMDStateModelArtifact((*source).Attributes) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiModelArtifact.State = pOpenapiArtifactState + pOpenapiModelArtifact = &openapiModelArtifact + } + return pOpenapiModelArtifact, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertModelVersion(source *models.BaseEntity[models.ModelVersionAttributes]) (*openapi.ModelVersion, error) { + var pOpenapiModelVersion *openapi.ModelVersion + if source != nil { + var openapiModelVersion openapi.ModelVersion + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiModelVersion.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiModelVersion.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiModelVersion.ExternalId = converter.MapEmbedMDExternalIDModelVersion((*source).Attributes) + openapiModelVersion.Name = converter.MapEmbedMDNameModelVersion((*source).Attributes) + pOpenapiModelVersionState, err := converter.MapEmbedMDStateModelVersion((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiModelVersion.State = pOpenapiModelVersionState + openapiModelVersion.Author = converter.MapEmbedMDAuthor((*source).Properties) + openapiModelVersion.RegisteredModelId = converter.MapEmbedMDPropertyRegisteredModelId((*source).Properties) + openapiModelVersion.Id = converter.Int32ToString((*source).ID) + openapiModelVersion.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochModelVersion((*source).Attributes) + openapiModelVersion.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochModelVersion((*source).Attributes) + pOpenapiModelVersion = &openapiModelVersion + } + return pOpenapiModelVersion, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertParameter(source *models.BaseEntity[models.ParameterAttributes]) (*openapi.Parameter, error) { + var pOpenapiParameter *openapi.Parameter + if source != nil { + var openapiParameter openapi.Parameter + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiParameter.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiParameter.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiParameter.ExternalId = converter.MapEmbedMDExternalIDParameter((*source).Attributes) + openapiParameter.Name = converter.MapEmbedMDNameParameter((*source).Attributes) + openapiParameter.Id = converter.Int32ToString((*source).ID) + openapiParameter.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochParameter((*source).Attributes) + openapiParameter.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochParameter((*source).Attributes) + openapiParameter.ExperimentId = converter.MapEmbedMDExperimentId((*source).CustomProperties) + openapiParameter.ExperimentRunId = converter.MapEmbedMDExperimentRunId((*source).CustomProperties) + openapiParameter.ArtifactType = converter.MapEmbedMDArtifactTypeParameter((*source).Attributes) + openapiParameter.Value = converter.MapEmbedMDPropertyValueParameter((*source).Properties) + pOpenapiParameterType, err := converter.MapEmbedMDPropertyParameterTypeParameter((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field ParameterType: %w", err) + } + openapiParameter.ParameterType = pOpenapiParameterType + pOpenapiArtifactState, err := converter.MapEmbedMDStateParameter((*source).Attributes) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiParameter.State = pOpenapiArtifactState + pOpenapiParameter = &openapiParameter + } + return pOpenapiParameter, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertRegisteredModel(source *models.BaseEntity[models.RegisteredModelAttributes]) (*openapi.RegisteredModel, error) { + var pOpenapiRegisteredModel *openapi.RegisteredModel + if source != nil { + var openapiRegisteredModel openapi.RegisteredModel + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiRegisteredModel.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiRegisteredModel.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiRegisteredModel.ExternalId = converter.MapEmbedMDExternalIDRegisteredModel((*source).Attributes) + openapiRegisteredModel.Name = converter.MapEmbedMDNameRegisteredModel((*source).Attributes) + openapiRegisteredModel.Id = converter.Int32ToString((*source).ID) + openapiRegisteredModel.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochRegisteredModel((*source).Attributes) + openapiRegisteredModel.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochRegisteredModel((*source).Attributes) + openapiRegisteredModel.Readme = converter.MapEmbedMDPropertyReadme((*source).Properties) + openapiRegisteredModel.Maturity = converter.MapEmbedMDPropertyMaturity((*source).Properties) + openapiRegisteredModel.Language = converter.MapEmbedMDPropertyLanguage((*source).Properties) + openapiRegisteredModel.Tasks = converter.MapEmbedMDPropertyTasks((*source).Properties) + openapiRegisteredModel.Provider = converter.MapEmbedMDPropertyProvider((*source).Properties) + openapiRegisteredModel.Logo = converter.MapEmbedMDPropertyLogo((*source).Properties) + openapiRegisteredModel.License = converter.MapEmbedMDPropertyLicense((*source).Properties) + openapiRegisteredModel.LicenseLink = converter.MapEmbedMDPropertyLicenseLink((*source).Properties) + openapiRegisteredModel.LibraryName = converter.MapEmbedMDPropertyLibraryName((*source).Properties) + openapiRegisteredModel.Owner = converter.MapEmbedMDOwner((*source).Properties) + pOpenapiRegisteredModelState, err := converter.MapEmbedMDStateRegisteredModel((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiRegisteredModel.State = pOpenapiRegisteredModelState + pOpenapiRegisteredModel = &openapiRegisteredModel + } + return pOpenapiRegisteredModel, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertServeModel(source *models.BaseEntity[models.ServeModelAttributes]) (*openapi.ServeModel, error) { + var pOpenapiServeModel *openapi.ServeModel + if source != nil { + var openapiServeModel openapi.ServeModel + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiServeModel.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiServeModel.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiServeModel.ExternalId = converter.MapEmbedMDExternalIDServeModel((*source).Attributes) + openapiServeModel.Name = converter.MapEmbedMDNameServeModel((*source).Attributes) + openapiServeModel.Id = converter.Int32ToString((*source).ID) + openapiServeModel.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochServeModel((*source).Attributes) + openapiServeModel.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochServeModel((*source).Attributes) + pOpenapiExecutionState, err := converter.MapEmbedMDLastKnownStateServeModel((*source).Attributes) + if err != nil { + return nil, fmt.Errorf("error setting field LastKnownState: %w", err) + } + openapiServeModel.LastKnownState = pOpenapiExecutionState + xstring, err := converter.MapEmbedMDPropertyModelVersionIdServeModel((*source).Properties) + if err != nil { + return nil, fmt.Errorf("error setting field ModelVersionId: %w", err) + } + openapiServeModel.ModelVersionId = xstring + pOpenapiServeModel = &openapiServeModel + } + return pOpenapiServeModel, nil +} +func (c *EmbedMDToOpenAPIConverterImpl) ConvertServingEnvironment(source *models.BaseEntity[models.ServingEnvironmentAttributes]) (*openapi.ServingEnvironment, error) { + var pOpenapiServingEnvironment *openapi.ServingEnvironment + if source != nil { + var openapiServingEnvironment openapi.ServingEnvironment + if (*source).CustomProperties != nil { + mapStringOpenapiMetadataValue, err := converter.MapEmbedMDCustomProperties((*(*source).CustomProperties)) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + openapiServingEnvironment.CustomProperties = &mapStringOpenapiMetadataValue + } + openapiServingEnvironment.Description = converter.MapEmbedMDDescription((*source).Properties) + openapiServingEnvironment.ExternalId = converter.MapEmbedMDExternalIDServingEnvironment((*source).Attributes) + openapiServingEnvironment.Name = converter.MapEmbedMDNameServingEnvironment((*source).Attributes) + openapiServingEnvironment.Id = converter.Int32ToString((*source).ID) + openapiServingEnvironment.CreateTimeSinceEpoch = converter.MapEmbedMDCreateTimeSinceEpochServingEnvironment((*source).Attributes) + openapiServingEnvironment.LastUpdateTimeSinceEpoch = converter.MapEmbedMDLastUpdateTimeSinceEpochServingEnvironment((*source).Attributes) + pOpenapiServingEnvironment = &openapiServingEnvironment + } + return pOpenapiServingEnvironment, nil +} diff --git a/internal/converter/generated/openapi_converter.gen.go b/internal/converter/generated/openapi_converter.gen.go new file mode 100644 index 000000000..fb27fb50a --- /dev/null +++ b/internal/converter/generated/openapi_converter.gen.go @@ -0,0 +1,1735 @@ +// Code generated by github.com/jmattheis/goverter, DO NOT EDIT. +//go:build !goverter + +package generated + +import ( + "fmt" + converter "github.com/kubeflow/model-registry/internal/converter" + openapi "github.com/kubeflow/model-registry/pkg/openapi" +) + +type OpenAPIConverterImpl struct{} + +func (c *OpenAPIConverterImpl) ConvertArtifactCreate(source *openapi.ArtifactCreate) (*openapi.Artifact, error) { + var pOpenapiArtifact *openapi.Artifact + if source != nil { + var openapiArtifact openapi.Artifact + pOpenapiDataSet, err := c.ConvertDataSetCreate((*source).DataSetCreate) + if err != nil { + return nil, fmt.Errorf("error setting field DataSet: %w", err) + } + openapiArtifact.DataSet = pOpenapiDataSet + pOpenapiDocArtifact, err := c.ConvertDocArtifactCreate((*source).DocArtifactCreate) + if err != nil { + return nil, fmt.Errorf("error setting field DocArtifact: %w", err) + } + openapiArtifact.DocArtifact = pOpenapiDocArtifact + pOpenapiMetric, err := c.ConvertMetricCreate((*source).MetricCreate) + if err != nil { + return nil, fmt.Errorf("error setting field Metric: %w", err) + } + openapiArtifact.Metric = pOpenapiMetric + pOpenapiModelArtifact, err := c.ConvertModelArtifactCreate((*source).ModelArtifactCreate) + if err != nil { + return nil, fmt.Errorf("error setting field ModelArtifact: %w", err) + } + openapiArtifact.ModelArtifact = pOpenapiModelArtifact + pOpenapiParameter, err := c.ConvertParameterCreate((*source).ParameterCreate) + if err != nil { + return nil, fmt.Errorf("error setting field Parameter: %w", err) + } + openapiArtifact.Parameter = pOpenapiParameter + pOpenapiArtifact = &openapiArtifact + } + return pOpenapiArtifact, nil +} +func (c *OpenAPIConverterImpl) ConvertArtifactUpdate(source *openapi.ArtifactUpdate) (*openapi.Artifact, error) { + var pOpenapiArtifact *openapi.Artifact + if source != nil { + var openapiArtifact openapi.Artifact + pOpenapiDataSet, err := c.ConvertDataSetUpdate((*source).DataSetUpdate) + if err != nil { + return nil, fmt.Errorf("error setting field DataSet: %w", err) + } + openapiArtifact.DataSet = pOpenapiDataSet + pOpenapiDocArtifact, err := c.ConvertDocArtifactUpdate((*source).DocArtifactUpdate) + if err != nil { + return nil, fmt.Errorf("error setting field DocArtifact: %w", err) + } + openapiArtifact.DocArtifact = pOpenapiDocArtifact + pOpenapiMetric, err := c.ConvertMetricUpdate((*source).MetricUpdate) + if err != nil { + return nil, fmt.Errorf("error setting field Metric: %w", err) + } + openapiArtifact.Metric = pOpenapiMetric + pOpenapiModelArtifact, err := c.ConvertModelArtifactUpdate((*source).ModelArtifactUpdate) + if err != nil { + return nil, fmt.Errorf("error setting field ModelArtifact: %w", err) + } + openapiArtifact.ModelArtifact = pOpenapiModelArtifact + pOpenapiParameter, err := c.ConvertParameterUpdate((*source).ParameterUpdate) + if err != nil { + return nil, fmt.Errorf("error setting field Parameter: %w", err) + } + openapiArtifact.Parameter = pOpenapiParameter + pOpenapiArtifact = &openapiArtifact + } + return pOpenapiArtifact, nil +} +func (c *OpenAPIConverterImpl) ConvertDataSetCreate(source *openapi.DataSetCreate) (*openapi.DataSet, error) { + var pOpenapiDataSet *openapi.DataSet + if source != nil { + var openapiDataSet openapi.DataSet + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiDataSet.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiDataSet.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiDataSet.ExternalId = &xstring2 + } + if (*source).Name != nil { + xstring3 := *(*source).Name + openapiDataSet.Name = &xstring3 + } + if (*source).Digest != nil { + xstring4 := *(*source).Digest + openapiDataSet.Digest = &xstring4 + } + if (*source).SourceType != nil { + xstring5 := *(*source).SourceType + openapiDataSet.SourceType = &xstring5 + } + if (*source).Source != nil { + xstring6 := *(*source).Source + openapiDataSet.Source = &xstring6 + } + if (*source).Schema != nil { + xstring7 := *(*source).Schema + openapiDataSet.Schema = &xstring7 + } + if (*source).Profile != nil { + xstring8 := *(*source).Profile + openapiDataSet.Profile = &xstring8 + } + if (*source).Uri != nil { + xstring9 := *(*source).Uri + openapiDataSet.Uri = &xstring9 + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiDataSet.State = &openapiArtifactState + } + pOpenapiDataSet = &openapiDataSet + } + return pOpenapiDataSet, nil +} +func (c *OpenAPIConverterImpl) ConvertDataSetUpdate(source *openapi.DataSetUpdate) (*openapi.DataSet, error) { + var pOpenapiDataSet *openapi.DataSet + if source != nil { + var openapiDataSet openapi.DataSet + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiDataSet.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiDataSet.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiDataSet.ExternalId = &xstring2 + } + if (*source).Digest != nil { + xstring3 := *(*source).Digest + openapiDataSet.Digest = &xstring3 + } + if (*source).SourceType != nil { + xstring4 := *(*source).SourceType + openapiDataSet.SourceType = &xstring4 + } + if (*source).Source != nil { + xstring5 := *(*source).Source + openapiDataSet.Source = &xstring5 + } + if (*source).Schema != nil { + xstring6 := *(*source).Schema + openapiDataSet.Schema = &xstring6 + } + if (*source).Profile != nil { + xstring7 := *(*source).Profile + openapiDataSet.Profile = &xstring7 + } + if (*source).Uri != nil { + xstring8 := *(*source).Uri + openapiDataSet.Uri = &xstring8 + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiDataSet.State = &openapiArtifactState + } + pOpenapiDataSet = &openapiDataSet + } + return pOpenapiDataSet, nil +} +func (c *OpenAPIConverterImpl) ConvertDocArtifactCreate(source *openapi.DocArtifactCreate) (*openapi.DocArtifact, error) { + var pOpenapiDocArtifact *openapi.DocArtifact + if source != nil { + var openapiDocArtifact openapi.DocArtifact + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiDocArtifact.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiDocArtifact.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiDocArtifact.ExternalId = &xstring2 + } + if (*source).Name != nil { + xstring3 := *(*source).Name + openapiDocArtifact.Name = &xstring3 + } + if (*source).Uri != nil { + xstring4 := *(*source).Uri + openapiDocArtifact.Uri = &xstring4 + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiDocArtifact.State = &openapiArtifactState + } + pOpenapiDocArtifact = &openapiDocArtifact + } + return pOpenapiDocArtifact, nil +} +func (c *OpenAPIConverterImpl) ConvertDocArtifactUpdate(source *openapi.DocArtifactUpdate) (*openapi.DocArtifact, error) { + var pOpenapiDocArtifact *openapi.DocArtifact + if source != nil { + var openapiDocArtifact openapi.DocArtifact + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiDocArtifact.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiDocArtifact.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiDocArtifact.ExternalId = &xstring2 + } + if (*source).Uri != nil { + xstring3 := *(*source).Uri + openapiDocArtifact.Uri = &xstring3 + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiDocArtifact.State = &openapiArtifactState + } + pOpenapiDocArtifact = &openapiDocArtifact + } + return pOpenapiDocArtifact, nil +} +func (c *OpenAPIConverterImpl) ConvertExperimentCreate(source *openapi.ExperimentCreate) (*openapi.Experiment, error) { + var pOpenapiExperiment *openapi.Experiment + if source != nil { + var openapiExperiment openapi.Experiment + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiExperiment.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiExperiment.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiExperiment.ExternalId = &xstring2 + } + openapiExperiment.Name = (*source).Name + if (*source).Owner != nil { + xstring3 := *(*source).Owner + openapiExperiment.Owner = &xstring3 + } + if (*source).State != nil { + openapiExperimentState, err := c.openapiExperimentStateToOpenapiExperimentState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiExperiment.State = &openapiExperimentState + } + pOpenapiExperiment = &openapiExperiment + } + return pOpenapiExperiment, nil +} +func (c *OpenAPIConverterImpl) ConvertExperimentRunCreate(source *openapi.ExperimentRunCreate) (*openapi.ExperimentRun, error) { + var pOpenapiExperimentRun *openapi.ExperimentRun + if source != nil { + var openapiExperimentRun openapi.ExperimentRun + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiExperimentRun.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiExperimentRun.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiExperimentRun.ExternalId = &xstring2 + } + if (*source).Name != nil { + xstring3 := *(*source).Name + openapiExperimentRun.Name = &xstring3 + } + if (*source).EndTimeSinceEpoch != nil { + xstring4 := *(*source).EndTimeSinceEpoch + openapiExperimentRun.EndTimeSinceEpoch = &xstring4 + } + if (*source).Status != nil { + openapiExperimentRunStatus, err := c.openapiExperimentRunStatusToOpenapiExperimentRunStatus(*(*source).Status) + if err != nil { + return nil, fmt.Errorf("error setting field Status: %w", err) + } + openapiExperimentRun.Status = &openapiExperimentRunStatus + } + if (*source).State != nil { + openapiExperimentRunState, err := c.openapiExperimentRunStateToOpenapiExperimentRunState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiExperimentRun.State = &openapiExperimentRunState + } + if (*source).Owner != nil { + xstring5 := *(*source).Owner + openapiExperimentRun.Owner = &xstring5 + } + openapiExperimentRun.ExperimentId = (*source).ExperimentId + if (*source).StartTimeSinceEpoch != nil { + xstring6 := *(*source).StartTimeSinceEpoch + openapiExperimentRun.StartTimeSinceEpoch = &xstring6 + } + pOpenapiExperimentRun = &openapiExperimentRun + } + return pOpenapiExperimentRun, nil +} +func (c *OpenAPIConverterImpl) ConvertExperimentRunUpdate(source *openapi.ExperimentRunUpdate) (*openapi.ExperimentRun, error) { + var pOpenapiExperimentRun *openapi.ExperimentRun + if source != nil { + var openapiExperimentRun openapi.ExperimentRun + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiExperimentRun.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiExperimentRun.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiExperimentRun.ExternalId = &xstring2 + } + if (*source).EndTimeSinceEpoch != nil { + xstring3 := *(*source).EndTimeSinceEpoch + openapiExperimentRun.EndTimeSinceEpoch = &xstring3 + } + if (*source).Status != nil { + openapiExperimentRunStatus, err := c.openapiExperimentRunStatusToOpenapiExperimentRunStatus(*(*source).Status) + if err != nil { + return nil, fmt.Errorf("error setting field Status: %w", err) + } + openapiExperimentRun.Status = &openapiExperimentRunStatus + } + if (*source).State != nil { + openapiExperimentRunState, err := c.openapiExperimentRunStateToOpenapiExperimentRunState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiExperimentRun.State = &openapiExperimentRunState + } + if (*source).Owner != nil { + xstring4 := *(*source).Owner + openapiExperimentRun.Owner = &xstring4 + } + pOpenapiExperimentRun = &openapiExperimentRun + } + return pOpenapiExperimentRun, nil +} +func (c *OpenAPIConverterImpl) ConvertExperimentUpdate(source *openapi.ExperimentUpdate) (*openapi.Experiment, error) { + var pOpenapiExperiment *openapi.Experiment + if source != nil { + var openapiExperiment openapi.Experiment + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiExperiment.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiExperiment.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiExperiment.ExternalId = &xstring2 + } + if (*source).Owner != nil { + xstring3 := *(*source).Owner + openapiExperiment.Owner = &xstring3 + } + if (*source).State != nil { + openapiExperimentState, err := c.openapiExperimentStateToOpenapiExperimentState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiExperiment.State = &openapiExperimentState + } + pOpenapiExperiment = &openapiExperiment + } + return pOpenapiExperiment, nil +} +func (c *OpenAPIConverterImpl) ConvertInferenceServiceCreate(source *openapi.InferenceServiceCreate) (*openapi.InferenceService, error) { + var pOpenapiInferenceService *openapi.InferenceService + if source != nil { + var openapiInferenceService openapi.InferenceService + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiInferenceService.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiInferenceService.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiInferenceService.ExternalId = &xstring2 + } + if (*source).Name != nil { + xstring3 := *(*source).Name + openapiInferenceService.Name = &xstring3 + } + if (*source).ModelVersionId != nil { + xstring4 := *(*source).ModelVersionId + openapiInferenceService.ModelVersionId = &xstring4 + } + if (*source).Runtime != nil { + xstring5 := *(*source).Runtime + openapiInferenceService.Runtime = &xstring5 + } + if (*source).DesiredState != nil { + openapiInferenceServiceState, err := c.openapiInferenceServiceStateToOpenapiInferenceServiceState(*(*source).DesiredState) + if err != nil { + return nil, fmt.Errorf("error setting field DesiredState: %w", err) + } + openapiInferenceService.DesiredState = &openapiInferenceServiceState + } + openapiInferenceService.RegisteredModelId = (*source).RegisteredModelId + openapiInferenceService.ServingEnvironmentId = (*source).ServingEnvironmentId + pOpenapiInferenceService = &openapiInferenceService + } + return pOpenapiInferenceService, nil +} +func (c *OpenAPIConverterImpl) ConvertInferenceServiceUpdate(source *openapi.InferenceServiceUpdate) (*openapi.InferenceService, error) { + var pOpenapiInferenceService *openapi.InferenceService + if source != nil { + var openapiInferenceService openapi.InferenceService + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiInferenceService.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiInferenceService.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiInferenceService.ExternalId = &xstring2 + } + if (*source).ModelVersionId != nil { + xstring3 := *(*source).ModelVersionId + openapiInferenceService.ModelVersionId = &xstring3 + } + if (*source).Runtime != nil { + xstring4 := *(*source).Runtime + openapiInferenceService.Runtime = &xstring4 + } + if (*source).DesiredState != nil { + openapiInferenceServiceState, err := c.openapiInferenceServiceStateToOpenapiInferenceServiceState(*(*source).DesiredState) + if err != nil { + return nil, fmt.Errorf("error setting field DesiredState: %w", err) + } + openapiInferenceService.DesiredState = &openapiInferenceServiceState + } + pOpenapiInferenceService = &openapiInferenceService + } + return pOpenapiInferenceService, nil +} +func (c *OpenAPIConverterImpl) ConvertMetricCreate(source *openapi.MetricCreate) (*openapi.Metric, error) { + var pOpenapiMetric *openapi.Metric + if source != nil { + var openapiMetric openapi.Metric + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiMetric.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiMetric.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiMetric.ExternalId = &xstring2 + } + if (*source).Name != nil { + xstring3 := *(*source).Name + openapiMetric.Name = &xstring3 + } + if (*source).Value != nil { + xfloat64 := *(*source).Value + openapiMetric.Value = &xfloat64 + } + if (*source).Timestamp != nil { + xstring4 := *(*source).Timestamp + openapiMetric.Timestamp = &xstring4 + } + if (*source).Step != nil { + xint64 := *(*source).Step + openapiMetric.Step = &xint64 + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiMetric.State = &openapiArtifactState + } + pOpenapiMetric = &openapiMetric + } + return pOpenapiMetric, nil +} +func (c *OpenAPIConverterImpl) ConvertMetricUpdate(source *openapi.MetricUpdate) (*openapi.Metric, error) { + var pOpenapiMetric *openapi.Metric + if source != nil { + var openapiMetric openapi.Metric + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiMetric.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiMetric.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiMetric.ExternalId = &xstring2 + } + if (*source).Value != nil { + xfloat64 := *(*source).Value + openapiMetric.Value = &xfloat64 + } + if (*source).Timestamp != nil { + xstring3 := *(*source).Timestamp + openapiMetric.Timestamp = &xstring3 + } + if (*source).Step != nil { + xint64 := *(*source).Step + openapiMetric.Step = &xint64 + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiMetric.State = &openapiArtifactState + } + pOpenapiMetric = &openapiMetric + } + return pOpenapiMetric, nil +} +func (c *OpenAPIConverterImpl) ConvertModelArtifactCreate(source *openapi.ModelArtifactCreate) (*openapi.ModelArtifact, error) { + var pOpenapiModelArtifact *openapi.ModelArtifact + if source != nil { + var openapiModelArtifact openapi.ModelArtifact + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiModelArtifact.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiModelArtifact.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiModelArtifact.ExternalId = &xstring2 + } + if (*source).Name != nil { + xstring3 := *(*source).Name + openapiModelArtifact.Name = &xstring3 + } + if (*source).ModelFormatName != nil { + xstring4 := *(*source).ModelFormatName + openapiModelArtifact.ModelFormatName = &xstring4 + } + if (*source).StorageKey != nil { + xstring5 := *(*source).StorageKey + openapiModelArtifact.StorageKey = &xstring5 + } + if (*source).StoragePath != nil { + xstring6 := *(*source).StoragePath + openapiModelArtifact.StoragePath = &xstring6 + } + if (*source).ModelFormatVersion != nil { + xstring7 := *(*source).ModelFormatVersion + openapiModelArtifact.ModelFormatVersion = &xstring7 + } + if (*source).ServiceAccountName != nil { + xstring8 := *(*source).ServiceAccountName + openapiModelArtifact.ServiceAccountName = &xstring8 + } + if (*source).ModelSourceKind != nil { + xstring9 := *(*source).ModelSourceKind + openapiModelArtifact.ModelSourceKind = &xstring9 + } + if (*source).ModelSourceClass != nil { + xstring10 := *(*source).ModelSourceClass + openapiModelArtifact.ModelSourceClass = &xstring10 + } + if (*source).ModelSourceGroup != nil { + xstring11 := *(*source).ModelSourceGroup + openapiModelArtifact.ModelSourceGroup = &xstring11 + } + if (*source).ModelSourceId != nil { + xstring12 := *(*source).ModelSourceId + openapiModelArtifact.ModelSourceId = &xstring12 + } + if (*source).ModelSourceName != nil { + xstring13 := *(*source).ModelSourceName + openapiModelArtifact.ModelSourceName = &xstring13 + } + if (*source).Uri != nil { + xstring14 := *(*source).Uri + openapiModelArtifact.Uri = &xstring14 + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiModelArtifact.State = &openapiArtifactState + } + pOpenapiModelArtifact = &openapiModelArtifact + } + return pOpenapiModelArtifact, nil +} +func (c *OpenAPIConverterImpl) ConvertModelArtifactUpdate(source *openapi.ModelArtifactUpdate) (*openapi.ModelArtifact, error) { + var pOpenapiModelArtifact *openapi.ModelArtifact + if source != nil { + var openapiModelArtifact openapi.ModelArtifact + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiModelArtifact.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiModelArtifact.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiModelArtifact.ExternalId = &xstring2 + } + if (*source).ModelFormatName != nil { + xstring3 := *(*source).ModelFormatName + openapiModelArtifact.ModelFormatName = &xstring3 + } + if (*source).StorageKey != nil { + xstring4 := *(*source).StorageKey + openapiModelArtifact.StorageKey = &xstring4 + } + if (*source).StoragePath != nil { + xstring5 := *(*source).StoragePath + openapiModelArtifact.StoragePath = &xstring5 + } + if (*source).ModelFormatVersion != nil { + xstring6 := *(*source).ModelFormatVersion + openapiModelArtifact.ModelFormatVersion = &xstring6 + } + if (*source).ServiceAccountName != nil { + xstring7 := *(*source).ServiceAccountName + openapiModelArtifact.ServiceAccountName = &xstring7 + } + if (*source).ModelSourceKind != nil { + xstring8 := *(*source).ModelSourceKind + openapiModelArtifact.ModelSourceKind = &xstring8 + } + if (*source).ModelSourceClass != nil { + xstring9 := *(*source).ModelSourceClass + openapiModelArtifact.ModelSourceClass = &xstring9 + } + if (*source).ModelSourceGroup != nil { + xstring10 := *(*source).ModelSourceGroup + openapiModelArtifact.ModelSourceGroup = &xstring10 + } + if (*source).ModelSourceId != nil { + xstring11 := *(*source).ModelSourceId + openapiModelArtifact.ModelSourceId = &xstring11 + } + if (*source).ModelSourceName != nil { + xstring12 := *(*source).ModelSourceName + openapiModelArtifact.ModelSourceName = &xstring12 + } + if (*source).Uri != nil { + xstring13 := *(*source).Uri + openapiModelArtifact.Uri = &xstring13 + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiModelArtifact.State = &openapiArtifactState + } + pOpenapiModelArtifact = &openapiModelArtifact + } + return pOpenapiModelArtifact, nil +} +func (c *OpenAPIConverterImpl) ConvertModelVersionCreate(source *openapi.ModelVersionCreate) (*openapi.ModelVersion, error) { + var pOpenapiModelVersion *openapi.ModelVersion + if source != nil { + var openapiModelVersion openapi.ModelVersion + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiModelVersion.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiModelVersion.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiModelVersion.ExternalId = &xstring2 + } + openapiModelVersion.Name = (*source).Name + if (*source).State != nil { + openapiModelVersionState, err := c.openapiModelVersionStateToOpenapiModelVersionState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiModelVersion.State = &openapiModelVersionState + } + if (*source).Author != nil { + xstring3 := *(*source).Author + openapiModelVersion.Author = &xstring3 + } + openapiModelVersion.RegisteredModelId = (*source).RegisteredModelId + pOpenapiModelVersion = &openapiModelVersion + } + return pOpenapiModelVersion, nil +} +func (c *OpenAPIConverterImpl) ConvertModelVersionUpdate(source *openapi.ModelVersionUpdate) (*openapi.ModelVersion, error) { + var pOpenapiModelVersion *openapi.ModelVersion + if source != nil { + var openapiModelVersion openapi.ModelVersion + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiModelVersion.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiModelVersion.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiModelVersion.ExternalId = &xstring2 + } + if (*source).State != nil { + openapiModelVersionState, err := c.openapiModelVersionStateToOpenapiModelVersionState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiModelVersion.State = &openapiModelVersionState + } + if (*source).Author != nil { + xstring3 := *(*source).Author + openapiModelVersion.Author = &xstring3 + } + pOpenapiModelVersion = &openapiModelVersion + } + return pOpenapiModelVersion, nil +} +func (c *OpenAPIConverterImpl) ConvertParameterCreate(source *openapi.ParameterCreate) (*openapi.Parameter, error) { + var pOpenapiParameter *openapi.Parameter + if source != nil { + var openapiParameter openapi.Parameter + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiParameter.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiParameter.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiParameter.ExternalId = &xstring2 + } + if (*source).Name != nil { + xstring3 := *(*source).Name + openapiParameter.Name = &xstring3 + } + if (*source).Value != nil { + xstring4 := *(*source).Value + openapiParameter.Value = &xstring4 + } + if (*source).ParameterType != nil { + openapiParameterType, err := c.openapiParameterTypeToOpenapiParameterType(*(*source).ParameterType) + if err != nil { + return nil, fmt.Errorf("error setting field ParameterType: %w", err) + } + openapiParameter.ParameterType = &openapiParameterType + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiParameter.State = &openapiArtifactState + } + pOpenapiParameter = &openapiParameter + } + return pOpenapiParameter, nil +} +func (c *OpenAPIConverterImpl) ConvertParameterUpdate(source *openapi.ParameterUpdate) (*openapi.Parameter, error) { + var pOpenapiParameter *openapi.Parameter + if source != nil { + var openapiParameter openapi.Parameter + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiParameter.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiParameter.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiParameter.ExternalId = &xstring2 + } + if (*source).Value != nil { + xstring3 := *(*source).Value + openapiParameter.Value = &xstring3 + } + if (*source).ParameterType != nil { + openapiParameterType, err := c.openapiParameterTypeToOpenapiParameterType(*(*source).ParameterType) + if err != nil { + return nil, fmt.Errorf("error setting field ParameterType: %w", err) + } + openapiParameter.ParameterType = &openapiParameterType + } + if (*source).State != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiParameter.State = &openapiArtifactState + } + pOpenapiParameter = &openapiParameter + } + return pOpenapiParameter, nil +} +func (c *OpenAPIConverterImpl) ConvertRegisteredModelCreate(source *openapi.RegisteredModelCreate) (*openapi.RegisteredModel, error) { + var pOpenapiRegisteredModel *openapi.RegisteredModel + if source != nil { + var openapiRegisteredModel openapi.RegisteredModel + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiRegisteredModel.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiRegisteredModel.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiRegisteredModel.ExternalId = &xstring2 + } + openapiRegisteredModel.Name = (*source).Name + if (*source).Readme != nil { + xstring3 := *(*source).Readme + openapiRegisteredModel.Readme = &xstring3 + } + if (*source).Maturity != nil { + xstring4 := *(*source).Maturity + openapiRegisteredModel.Maturity = &xstring4 + } + if (*source).Language != nil { + openapiRegisteredModel.Language = make([]string, len((*source).Language)) + for i := 0; i < len((*source).Language); i++ { + openapiRegisteredModel.Language[i] = (*source).Language[i] + } + } + if (*source).Tasks != nil { + openapiRegisteredModel.Tasks = make([]string, len((*source).Tasks)) + for j := 0; j < len((*source).Tasks); j++ { + openapiRegisteredModel.Tasks[j] = (*source).Tasks[j] + } + } + if (*source).Provider != nil { + xstring5 := *(*source).Provider + openapiRegisteredModel.Provider = &xstring5 + } + if (*source).Logo != nil { + xstring6 := *(*source).Logo + openapiRegisteredModel.Logo = &xstring6 + } + if (*source).License != nil { + xstring7 := *(*source).License + openapiRegisteredModel.License = &xstring7 + } + if (*source).LicenseLink != nil { + xstring8 := *(*source).LicenseLink + openapiRegisteredModel.LicenseLink = &xstring8 + } + if (*source).LibraryName != nil { + xstring9 := *(*source).LibraryName + openapiRegisteredModel.LibraryName = &xstring9 + } + if (*source).Owner != nil { + xstring10 := *(*source).Owner + openapiRegisteredModel.Owner = &xstring10 + } + if (*source).State != nil { + openapiRegisteredModelState, err := c.openapiRegisteredModelStateToOpenapiRegisteredModelState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiRegisteredModel.State = &openapiRegisteredModelState + } + pOpenapiRegisteredModel = &openapiRegisteredModel + } + return pOpenapiRegisteredModel, nil +} +func (c *OpenAPIConverterImpl) ConvertRegisteredModelUpdate(source *openapi.RegisteredModelUpdate) (*openapi.RegisteredModel, error) { + var pOpenapiRegisteredModel *openapi.RegisteredModel + if source != nil { + var openapiRegisteredModel openapi.RegisteredModel + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiRegisteredModel.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiRegisteredModel.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiRegisteredModel.ExternalId = &xstring2 + } + if (*source).Readme != nil { + xstring3 := *(*source).Readme + openapiRegisteredModel.Readme = &xstring3 + } + if (*source).Maturity != nil { + xstring4 := *(*source).Maturity + openapiRegisteredModel.Maturity = &xstring4 + } + if (*source).Language != nil { + openapiRegisteredModel.Language = make([]string, len((*source).Language)) + for i := 0; i < len((*source).Language); i++ { + openapiRegisteredModel.Language[i] = (*source).Language[i] + } + } + if (*source).Tasks != nil { + openapiRegisteredModel.Tasks = make([]string, len((*source).Tasks)) + for j := 0; j < len((*source).Tasks); j++ { + openapiRegisteredModel.Tasks[j] = (*source).Tasks[j] + } + } + if (*source).Provider != nil { + xstring5 := *(*source).Provider + openapiRegisteredModel.Provider = &xstring5 + } + if (*source).Logo != nil { + xstring6 := *(*source).Logo + openapiRegisteredModel.Logo = &xstring6 + } + if (*source).License != nil { + xstring7 := *(*source).License + openapiRegisteredModel.License = &xstring7 + } + if (*source).LicenseLink != nil { + xstring8 := *(*source).LicenseLink + openapiRegisteredModel.LicenseLink = &xstring8 + } + if (*source).LibraryName != nil { + xstring9 := *(*source).LibraryName + openapiRegisteredModel.LibraryName = &xstring9 + } + if (*source).Owner != nil { + xstring10 := *(*source).Owner + openapiRegisteredModel.Owner = &xstring10 + } + if (*source).State != nil { + openapiRegisteredModelState, err := c.openapiRegisteredModelStateToOpenapiRegisteredModelState(*(*source).State) + if err != nil { + return nil, fmt.Errorf("error setting field State: %w", err) + } + openapiRegisteredModel.State = &openapiRegisteredModelState + } + pOpenapiRegisteredModel = &openapiRegisteredModel + } + return pOpenapiRegisteredModel, nil +} +func (c *OpenAPIConverterImpl) ConvertServeModelCreate(source *openapi.ServeModelCreate) (*openapi.ServeModel, error) { + var pOpenapiServeModel *openapi.ServeModel + if source != nil { + var openapiServeModel openapi.ServeModel + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiServeModel.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiServeModel.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiServeModel.ExternalId = &xstring2 + } + if (*source).Name != nil { + xstring3 := *(*source).Name + openapiServeModel.Name = &xstring3 + } + if (*source).LastKnownState != nil { + openapiExecutionState, err := c.openapiExecutionStateToOpenapiExecutionState(*(*source).LastKnownState) + if err != nil { + return nil, fmt.Errorf("error setting field LastKnownState: %w", err) + } + openapiServeModel.LastKnownState = &openapiExecutionState + } + openapiServeModel.ModelVersionId = (*source).ModelVersionId + pOpenapiServeModel = &openapiServeModel + } + return pOpenapiServeModel, nil +} +func (c *OpenAPIConverterImpl) ConvertServeModelUpdate(source *openapi.ServeModelUpdate) (*openapi.ServeModel, error) { + var pOpenapiServeModel *openapi.ServeModel + if source != nil { + var openapiServeModel openapi.ServeModel + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiServeModel.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiServeModel.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiServeModel.ExternalId = &xstring2 + } + if (*source).LastKnownState != nil { + openapiExecutionState, err := c.openapiExecutionStateToOpenapiExecutionState(*(*source).LastKnownState) + if err != nil { + return nil, fmt.Errorf("error setting field LastKnownState: %w", err) + } + openapiServeModel.LastKnownState = &openapiExecutionState + } + pOpenapiServeModel = &openapiServeModel + } + return pOpenapiServeModel, nil +} +func (c *OpenAPIConverterImpl) ConvertServingEnvironmentCreate(source *openapi.ServingEnvironmentCreate) (*openapi.ServingEnvironment, error) { + var pOpenapiServingEnvironment *openapi.ServingEnvironment + if source != nil { + var openapiServingEnvironment openapi.ServingEnvironment + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiServingEnvironment.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiServingEnvironment.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiServingEnvironment.ExternalId = &xstring2 + } + openapiServingEnvironment.Name = (*source).Name + pOpenapiServingEnvironment = &openapiServingEnvironment + } + return pOpenapiServingEnvironment, nil +} +func (c *OpenAPIConverterImpl) ConvertServingEnvironmentUpdate(source *openapi.ServingEnvironmentUpdate) (*openapi.ServingEnvironment, error) { + var pOpenapiServingEnvironment *openapi.ServingEnvironment + if source != nil { + var openapiServingEnvironment openapi.ServingEnvironment + if (*source).CustomProperties != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*(*source).CustomProperties) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*(*source).CustomProperties))) + for key, value := range *(*source).CustomProperties { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiServingEnvironment.CustomProperties = &mapStringOpenapiMetadataValue + } + if (*source).Description != nil { + xstring := *(*source).Description + openapiServingEnvironment.Description = &xstring + } + if (*source).ExternalId != nil { + xstring2 := *(*source).ExternalId + openapiServingEnvironment.ExternalId = &xstring2 + } + pOpenapiServingEnvironment = &openapiServingEnvironment + } + return pOpenapiServingEnvironment, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForArtifact(source converter.OpenapiUpdateWrapper[openapi.Artifact]) (openapi.Artifact, error) { + openapiArtifact := converter.InitWithUpdate(source) + _ = source + return openapiArtifact, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForDataSet(source converter.OpenapiUpdateWrapper[openapi.DataSet]) (openapi.DataSet, error) { + openapiDataSet := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = source.Existing.Name + } + if pString != nil { + xstring := *pString + openapiDataSet.Name = &xstring + } + var pString2 *string + if source.Existing != nil { + pString2 = source.Existing.ExperimentId + } + if pString2 != nil { + xstring2 := *pString2 + openapiDataSet.ExperimentId = &xstring2 + } + var pString3 *string + if source.Existing != nil { + pString3 = source.Existing.ExperimentRunId + } + if pString3 != nil { + xstring3 := *pString3 + openapiDataSet.ExperimentRunId = &xstring3 + } + var pString4 *string + if source.Existing != nil { + pString4 = source.Existing.ArtifactType + } + if pString4 != nil { + xstring4 := *pString4 + openapiDataSet.ArtifactType = &xstring4 + } + return openapiDataSet, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForDocArtifact(source converter.OpenapiUpdateWrapper[openapi.DocArtifact]) (openapi.DocArtifact, error) { + openapiDocArtifact := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = source.Existing.ExperimentId + } + if pString != nil { + xstring := *pString + openapiDocArtifact.ExperimentId = &xstring + } + var pString2 *string + if source.Existing != nil { + pString2 = source.Existing.ExperimentRunId + } + if pString2 != nil { + xstring2 := *pString2 + openapiDocArtifact.ExperimentRunId = &xstring2 + } + return openapiDocArtifact, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForExperiment(source converter.OpenapiUpdateWrapper[openapi.Experiment]) (openapi.Experiment, error) { + openapiExperiment := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = &source.Existing.Name + } + if pString != nil { + openapiExperiment.Name = *pString + } + return openapiExperiment, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForExperimentRun(source converter.OpenapiUpdateWrapper[openapi.ExperimentRun]) (openapi.ExperimentRun, error) { + openapiExperimentRun := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = source.Existing.Name + } + if pString != nil { + xstring := *pString + openapiExperimentRun.Name = &xstring + } + var pString2 *string + if source.Existing != nil { + pString2 = &source.Existing.ExperimentId + } + if pString2 != nil { + openapiExperimentRun.ExperimentId = *pString2 + } + return openapiExperimentRun, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForInferenceService(source converter.OpenapiUpdateWrapper[openapi.InferenceService]) (openapi.InferenceService, error) { + openapiInferenceService := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = source.Existing.Name + } + if pString != nil { + xstring := *pString + openapiInferenceService.Name = &xstring + } + var pString2 *string + if source.Existing != nil { + pString2 = &source.Existing.RegisteredModelId + } + if pString2 != nil { + openapiInferenceService.RegisteredModelId = *pString2 + } + var pString3 *string + if source.Existing != nil { + pString3 = &source.Existing.ServingEnvironmentId + } + if pString3 != nil { + openapiInferenceService.ServingEnvironmentId = *pString3 + } + return openapiInferenceService, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForMetric(source converter.OpenapiUpdateWrapper[openapi.Metric]) (openapi.Metric, error) { + openapiMetric := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = source.Existing.Name + } + if pString != nil { + xstring := *pString + openapiMetric.Name = &xstring + } + var pString2 *string + if source.Existing != nil { + pString2 = source.Existing.ExperimentId + } + if pString2 != nil { + xstring2 := *pString2 + openapiMetric.ExperimentId = &xstring2 + } + var pString3 *string + if source.Existing != nil { + pString3 = source.Existing.ExperimentRunId + } + if pString3 != nil { + xstring3 := *pString3 + openapiMetric.ExperimentRunId = &xstring3 + } + var pString4 *string + if source.Existing != nil { + pString4 = source.Existing.ArtifactType + } + if pString4 != nil { + xstring4 := *pString4 + openapiMetric.ArtifactType = &xstring4 + } + return openapiMetric, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForModelArtifact(source converter.OpenapiUpdateWrapper[openapi.ModelArtifact]) (openapi.ModelArtifact, error) { + openapiModelArtifact := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = source.Existing.Name + } + if pString != nil { + xstring := *pString + openapiModelArtifact.Name = &xstring + } + var pString2 *string + if source.Existing != nil { + pString2 = source.Existing.ExperimentId + } + if pString2 != nil { + xstring2 := *pString2 + openapiModelArtifact.ExperimentId = &xstring2 + } + var pString3 *string + if source.Existing != nil { + pString3 = source.Existing.ExperimentRunId + } + if pString3 != nil { + xstring3 := *pString3 + openapiModelArtifact.ExperimentRunId = &xstring3 + } + var pString4 *string + if source.Existing != nil { + pString4 = source.Existing.ArtifactType + } + if pString4 != nil { + xstring4 := *pString4 + openapiModelArtifact.ArtifactType = &xstring4 + } + return openapiModelArtifact, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForModelVersion(source converter.OpenapiUpdateWrapper[openapi.ModelVersion]) (openapi.ModelVersion, error) { + openapiModelVersion := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = &source.Existing.Name + } + if pString != nil { + openapiModelVersion.Name = *pString + } + var pString2 *string + if source.Existing != nil { + pString2 = &source.Existing.RegisteredModelId + } + if pString2 != nil { + openapiModelVersion.RegisteredModelId = *pString2 + } + return openapiModelVersion, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForParameter(source converter.OpenapiUpdateWrapper[openapi.Parameter]) (openapi.Parameter, error) { + openapiParameter := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = source.Existing.Name + } + if pString != nil { + xstring := *pString + openapiParameter.Name = &xstring + } + var pString2 *string + if source.Existing != nil { + pString2 = source.Existing.ExperimentId + } + if pString2 != nil { + xstring2 := *pString2 + openapiParameter.ExperimentId = &xstring2 + } + var pString3 *string + if source.Existing != nil { + pString3 = source.Existing.ExperimentRunId + } + if pString3 != nil { + xstring3 := *pString3 + openapiParameter.ExperimentRunId = &xstring3 + } + var pString4 *string + if source.Existing != nil { + pString4 = source.Existing.ArtifactType + } + if pString4 != nil { + xstring4 := *pString4 + openapiParameter.ArtifactType = &xstring4 + } + return openapiParameter, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForRegisteredModel(source converter.OpenapiUpdateWrapper[openapi.RegisteredModel]) (openapi.RegisteredModel, error) { + openapiRegisteredModel := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = &source.Existing.Name + } + if pString != nil { + openapiRegisteredModel.Name = *pString + } + return openapiRegisteredModel, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForServeModel(source converter.OpenapiUpdateWrapper[openapi.ServeModel]) (openapi.ServeModel, error) { + openapiServeModel := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = source.Existing.Name + } + if pString != nil { + xstring := *pString + openapiServeModel.Name = &xstring + } + var pString2 *string + if source.Existing != nil { + pString2 = &source.Existing.ModelVersionId + } + if pString2 != nil { + openapiServeModel.ModelVersionId = *pString2 + } + return openapiServeModel, nil +} +func (c *OpenAPIConverterImpl) OverrideNotEditableForServingEnvironment(source converter.OpenapiUpdateWrapper[openapi.ServingEnvironment]) (openapi.ServingEnvironment, error) { + openapiServingEnvironment := converter.InitWithUpdate(source) + var pString *string + if source.Existing != nil { + pString = &source.Existing.Name + } + if pString != nil { + openapiServingEnvironment.Name = *pString + } + return openapiServingEnvironment, nil +} +func (c *OpenAPIConverterImpl) openapiArtifactStateToOpenapiArtifactState(source openapi.ArtifactState) (openapi.ArtifactState, error) { + var openapiArtifactState openapi.ArtifactState + switch source { + case openapi.ARTIFACTSTATE_ABANDONED: + openapiArtifactState = openapi.ARTIFACTSTATE_ABANDONED + case openapi.ARTIFACTSTATE_DELETED: + openapiArtifactState = openapi.ARTIFACTSTATE_DELETED + case openapi.ARTIFACTSTATE_LIVE: + openapiArtifactState = openapi.ARTIFACTSTATE_LIVE + case openapi.ARTIFACTSTATE_MARKED_FOR_DELETION: + openapiArtifactState = openapi.ARTIFACTSTATE_MARKED_FOR_DELETION + case openapi.ARTIFACTSTATE_PENDING: + openapiArtifactState = openapi.ARTIFACTSTATE_PENDING + case openapi.ARTIFACTSTATE_REFERENCE: + openapiArtifactState = openapi.ARTIFACTSTATE_REFERENCE + case openapi.ARTIFACTSTATE_UNKNOWN: + openapiArtifactState = openapi.ARTIFACTSTATE_UNKNOWN + default: + return openapiArtifactState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiArtifactState, nil +} +func (c *OpenAPIConverterImpl) openapiExecutionStateToOpenapiExecutionState(source openapi.ExecutionState) (openapi.ExecutionState, error) { + var openapiExecutionState openapi.ExecutionState + switch source { + case openapi.EXECUTIONSTATE_CACHED: + openapiExecutionState = openapi.EXECUTIONSTATE_CACHED + case openapi.EXECUTIONSTATE_CANCELED: + openapiExecutionState = openapi.EXECUTIONSTATE_CANCELED + case openapi.EXECUTIONSTATE_COMPLETE: + openapiExecutionState = openapi.EXECUTIONSTATE_COMPLETE + case openapi.EXECUTIONSTATE_FAILED: + openapiExecutionState = openapi.EXECUTIONSTATE_FAILED + case openapi.EXECUTIONSTATE_NEW: + openapiExecutionState = openapi.EXECUTIONSTATE_NEW + case openapi.EXECUTIONSTATE_RUNNING: + openapiExecutionState = openapi.EXECUTIONSTATE_RUNNING + case openapi.EXECUTIONSTATE_UNKNOWN: + openapiExecutionState = openapi.EXECUTIONSTATE_UNKNOWN + default: + return openapiExecutionState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiExecutionState, nil +} +func (c *OpenAPIConverterImpl) openapiExperimentRunStateToOpenapiExperimentRunState(source openapi.ExperimentRunState) (openapi.ExperimentRunState, error) { + var openapiExperimentRunState openapi.ExperimentRunState + switch source { + case openapi.EXPERIMENTRUNSTATE_ARCHIVED: + openapiExperimentRunState = openapi.EXPERIMENTRUNSTATE_ARCHIVED + case openapi.EXPERIMENTRUNSTATE_LIVE: + openapiExperimentRunState = openapi.EXPERIMENTRUNSTATE_LIVE + default: + return openapiExperimentRunState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiExperimentRunState, nil +} +func (c *OpenAPIConverterImpl) openapiExperimentRunStatusToOpenapiExperimentRunStatus(source openapi.ExperimentRunStatus) (openapi.ExperimentRunStatus, error) { + var openapiExperimentRunStatus openapi.ExperimentRunStatus + switch source { + case openapi.EXPERIMENTRUNSTATUS_FAILED: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_FAILED + case openapi.EXPERIMENTRUNSTATUS_FINISHED: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_FINISHED + case openapi.EXPERIMENTRUNSTATUS_KILLED: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_KILLED + case openapi.EXPERIMENTRUNSTATUS_RUNNING: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_RUNNING + case openapi.EXPERIMENTRUNSTATUS_SCHEDULED: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_SCHEDULED + default: + return openapiExperimentRunStatus, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiExperimentRunStatus, nil +} +func (c *OpenAPIConverterImpl) openapiExperimentStateToOpenapiExperimentState(source openapi.ExperimentState) (openapi.ExperimentState, error) { + var openapiExperimentState openapi.ExperimentState + switch source { + case openapi.EXPERIMENTSTATE_ARCHIVED: + openapiExperimentState = openapi.EXPERIMENTSTATE_ARCHIVED + case openapi.EXPERIMENTSTATE_LIVE: + openapiExperimentState = openapi.EXPERIMENTSTATE_LIVE + default: + return openapiExperimentState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiExperimentState, nil +} +func (c *OpenAPIConverterImpl) openapiInferenceServiceStateToOpenapiInferenceServiceState(source openapi.InferenceServiceState) (openapi.InferenceServiceState, error) { + var openapiInferenceServiceState openapi.InferenceServiceState + switch source { + case openapi.INFERENCESERVICESTATE_DEPLOYED: + openapiInferenceServiceState = openapi.INFERENCESERVICESTATE_DEPLOYED + case openapi.INFERENCESERVICESTATE_UNDEPLOYED: + openapiInferenceServiceState = openapi.INFERENCESERVICESTATE_UNDEPLOYED + default: + return openapiInferenceServiceState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiInferenceServiceState, nil +} +func (c *OpenAPIConverterImpl) openapiMetadataValueToOpenapiMetadataValue(source openapi.MetadataValue) openapi.MetadataValue { + var openapiMetadataValue openapi.MetadataValue + openapiMetadataValue.MetadataBoolValue = c.pOpenapiMetadataBoolValueToPOpenapiMetadataBoolValue(source.MetadataBoolValue) + openapiMetadataValue.MetadataDoubleValue = c.pOpenapiMetadataDoubleValueToPOpenapiMetadataDoubleValue(source.MetadataDoubleValue) + openapiMetadataValue.MetadataIntValue = c.pOpenapiMetadataIntValueToPOpenapiMetadataIntValue(source.MetadataIntValue) + openapiMetadataValue.MetadataProtoValue = c.pOpenapiMetadataProtoValueToPOpenapiMetadataProtoValue(source.MetadataProtoValue) + openapiMetadataValue.MetadataStringValue = c.pOpenapiMetadataStringValueToPOpenapiMetadataStringValue(source.MetadataStringValue) + openapiMetadataValue.MetadataStructValue = c.pOpenapiMetadataStructValueToPOpenapiMetadataStructValue(source.MetadataStructValue) + return openapiMetadataValue +} +func (c *OpenAPIConverterImpl) openapiModelVersionStateToOpenapiModelVersionState(source openapi.ModelVersionState) (openapi.ModelVersionState, error) { + var openapiModelVersionState openapi.ModelVersionState + switch source { + case openapi.MODELVERSIONSTATE_ARCHIVED: + openapiModelVersionState = openapi.MODELVERSIONSTATE_ARCHIVED + case openapi.MODELVERSIONSTATE_LIVE: + openapiModelVersionState = openapi.MODELVERSIONSTATE_LIVE + default: + return openapiModelVersionState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiModelVersionState, nil +} +func (c *OpenAPIConverterImpl) openapiParameterTypeToOpenapiParameterType(source openapi.ParameterType) (openapi.ParameterType, error) { + var openapiParameterType openapi.ParameterType + switch source { + case openapi.PARAMETERTYPE_BOOLEAN: + openapiParameterType = openapi.PARAMETERTYPE_BOOLEAN + case openapi.PARAMETERTYPE_NUMBER: + openapiParameterType = openapi.PARAMETERTYPE_NUMBER + case openapi.PARAMETERTYPE_OBJECT: + openapiParameterType = openapi.PARAMETERTYPE_OBJECT + case openapi.PARAMETERTYPE_STRING: + openapiParameterType = openapi.PARAMETERTYPE_STRING + default: + return openapiParameterType, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiParameterType, nil +} +func (c *OpenAPIConverterImpl) openapiRegisteredModelStateToOpenapiRegisteredModelState(source openapi.RegisteredModelState) (openapi.RegisteredModelState, error) { + var openapiRegisteredModelState openapi.RegisteredModelState + switch source { + case openapi.REGISTEREDMODELSTATE_ARCHIVED: + openapiRegisteredModelState = openapi.REGISTEREDMODELSTATE_ARCHIVED + case openapi.REGISTEREDMODELSTATE_LIVE: + openapiRegisteredModelState = openapi.REGISTEREDMODELSTATE_LIVE + default: + return openapiRegisteredModelState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiRegisteredModelState, nil +} +func (c *OpenAPIConverterImpl) pOpenapiMetadataBoolValueToPOpenapiMetadataBoolValue(source *openapi.MetadataBoolValue) *openapi.MetadataBoolValue { + var pOpenapiMetadataBoolValue *openapi.MetadataBoolValue + if source != nil { + var openapiMetadataBoolValue openapi.MetadataBoolValue + openapiMetadataBoolValue.BoolValue = (*source).BoolValue + openapiMetadataBoolValue.MetadataType = (*source).MetadataType + pOpenapiMetadataBoolValue = &openapiMetadataBoolValue + } + return pOpenapiMetadataBoolValue +} +func (c *OpenAPIConverterImpl) pOpenapiMetadataDoubleValueToPOpenapiMetadataDoubleValue(source *openapi.MetadataDoubleValue) *openapi.MetadataDoubleValue { + var pOpenapiMetadataDoubleValue *openapi.MetadataDoubleValue + if source != nil { + var openapiMetadataDoubleValue openapi.MetadataDoubleValue + openapiMetadataDoubleValue.DoubleValue = (*source).DoubleValue + openapiMetadataDoubleValue.MetadataType = (*source).MetadataType + pOpenapiMetadataDoubleValue = &openapiMetadataDoubleValue + } + return pOpenapiMetadataDoubleValue +} +func (c *OpenAPIConverterImpl) pOpenapiMetadataIntValueToPOpenapiMetadataIntValue(source *openapi.MetadataIntValue) *openapi.MetadataIntValue { + var pOpenapiMetadataIntValue *openapi.MetadataIntValue + if source != nil { + var openapiMetadataIntValue openapi.MetadataIntValue + openapiMetadataIntValue.IntValue = (*source).IntValue + openapiMetadataIntValue.MetadataType = (*source).MetadataType + pOpenapiMetadataIntValue = &openapiMetadataIntValue + } + return pOpenapiMetadataIntValue +} +func (c *OpenAPIConverterImpl) pOpenapiMetadataProtoValueToPOpenapiMetadataProtoValue(source *openapi.MetadataProtoValue) *openapi.MetadataProtoValue { + var pOpenapiMetadataProtoValue *openapi.MetadataProtoValue + if source != nil { + var openapiMetadataProtoValue openapi.MetadataProtoValue + openapiMetadataProtoValue.Type = (*source).Type + openapiMetadataProtoValue.ProtoValue = (*source).ProtoValue + openapiMetadataProtoValue.MetadataType = (*source).MetadataType + pOpenapiMetadataProtoValue = &openapiMetadataProtoValue + } + return pOpenapiMetadataProtoValue +} +func (c *OpenAPIConverterImpl) pOpenapiMetadataStringValueToPOpenapiMetadataStringValue(source *openapi.MetadataStringValue) *openapi.MetadataStringValue { + var pOpenapiMetadataStringValue *openapi.MetadataStringValue + if source != nil { + var openapiMetadataStringValue openapi.MetadataStringValue + openapiMetadataStringValue.StringValue = (*source).StringValue + openapiMetadataStringValue.MetadataType = (*source).MetadataType + pOpenapiMetadataStringValue = &openapiMetadataStringValue + } + return pOpenapiMetadataStringValue +} +func (c *OpenAPIConverterImpl) pOpenapiMetadataStructValueToPOpenapiMetadataStructValue(source *openapi.MetadataStructValue) *openapi.MetadataStructValue { + var pOpenapiMetadataStructValue *openapi.MetadataStructValue + if source != nil { + var openapiMetadataStructValue openapi.MetadataStructValue + openapiMetadataStructValue.StructValue = (*source).StructValue + openapiMetadataStructValue.MetadataType = (*source).MetadataType + pOpenapiMetadataStructValue = &openapiMetadataStructValue + } + return pOpenapiMetadataStructValue +} diff --git a/internal/converter/generated/openapi_embedmd_converter.gen.go b/internal/converter/generated/openapi_embedmd_converter.gen.go new file mode 100644 index 000000000..fce57daec --- /dev/null +++ b/internal/converter/generated/openapi_embedmd_converter.gen.go @@ -0,0 +1,530 @@ +// Code generated by github.com/jmattheis/goverter, DO NOT EDIT. +//go:build !goverter + +package generated + +import ( + "fmt" + converter "github.com/kubeflow/model-registry/internal/converter" + models "github.com/kubeflow/model-registry/internal/db/models" + openapi "github.com/kubeflow/model-registry/pkg/openapi" +) + +type OpenAPIToEmbedMDConverterImpl struct{} + +func (c *OpenAPIToEmbedMDConverterImpl) ConvertDataSet(source *converter.OpenAPIModelWrapper[openapi.DataSet]) (*models.BaseEntity[models.DataSetAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.DataSetAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.DataSetAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapDataSetTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsDataSetAttributes, err := converter.MapDataSetAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsDataSetAttributes + pModelsPropertiesList, err := converter.MapDataSetPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertDocArtifact(source *converter.OpenAPIModelWrapper[openapi.DocArtifact]) (*models.BaseEntity[models.DocArtifactAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.DocArtifactAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.DocArtifactAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapDocArtifactTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsDocArtifactAttributes, err := converter.MapDocArtifactAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsDocArtifactAttributes + pModelsPropertiesList, err := converter.MapDocArtifactPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertExperiment(source *converter.OpenAPIModelWrapper[openapi.Experiment]) (*models.BaseEntity[models.ExperimentAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.ExperimentAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.ExperimentAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapExperimentTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsExperimentAttributes, err := converter.MapExperimentAttributesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsExperimentAttributes + pModelsPropertiesList, err := converter.MapExperimentPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertExperimentRun(source *converter.OpenAPIModelWrapper[openapi.ExperimentRun]) (*models.BaseEntity[models.ExperimentRunAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.ExperimentRunAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.ExperimentRunAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapExperimentRunTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsExperimentRunAttributes, err := converter.MapExperimentRunAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsExperimentRunAttributes + pModelsPropertiesList, err := converter.MapExperimentRunPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertInferenceService(source *converter.OpenAPIModelWrapper[openapi.InferenceService]) (*models.BaseEntity[models.InferenceServiceAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.InferenceServiceAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.InferenceServiceAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapInferenceServiceTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsInferenceServiceAttributes, err := converter.MapInferenceServiceAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsInferenceServiceAttributes + pModelsPropertiesList, err := converter.MapInferenceServicePropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertMetric(source *converter.OpenAPIModelWrapper[openapi.Metric]) (*models.BaseEntity[models.MetricAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.MetricAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.MetricAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapMetricTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsMetricAttributes, err := converter.MapMetricAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsMetricAttributes + pModelsPropertiesList, err := converter.MapMetricPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertModelArtifact(source *converter.OpenAPIModelWrapper[openapi.ModelArtifact]) (*models.BaseEntity[models.ModelArtifactAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.ModelArtifactAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.ModelArtifactAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapModelArtifactTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsModelArtifactAttributes, err := converter.MapModelArtifactAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsModelArtifactAttributes + pModelsPropertiesList, err := converter.MapModelArtifactPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertModelVersion(source *converter.OpenAPIModelWrapper[openapi.ModelVersion]) (*models.BaseEntity[models.ModelVersionAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.ModelVersionAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.ModelVersionAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapModelVersionTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsModelVersionAttributes, err := converter.MapModelVersionAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsModelVersionAttributes + pModelsPropertiesList, err := converter.MapModelVersionPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertParameter(source *converter.OpenAPIModelWrapper[openapi.Parameter]) (*models.BaseEntity[models.ParameterAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.ParameterAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.ParameterAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapParameterTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsParameterAttributes, err := converter.MapParameterAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsParameterAttributes + pModelsPropertiesList, err := converter.MapParameterPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertRegisteredModel(source *converter.OpenAPIModelWrapper[openapi.RegisteredModel]) (*models.BaseEntity[models.RegisteredModelAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.RegisteredModelAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.RegisteredModelAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapRegisteredModelTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsRegisteredModelAttributes, err := converter.MapRegisteredModelAttributesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsRegisteredModelAttributes + pModelsPropertiesList, err := converter.MapRegisteredModelPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertServeModel(source *converter.OpenAPIModelWrapper[openapi.ServeModel]) (*models.BaseEntity[models.ServeModelAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.ServeModelAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.ServeModelAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapServeModelTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsServeModelAttributes, err := converter.MapServeModelAttributesEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsServeModelAttributes + pModelsPropertiesList, err := converter.MapServeModelPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} +func (c *OpenAPIToEmbedMDConverterImpl) ConvertServingEnvironment(source *converter.OpenAPIModelWrapper[openapi.ServingEnvironment]) (*models.BaseEntity[models.ServingEnvironmentAttributes], error) { + var pModelsBaseEntity *models.BaseEntity[models.ServingEnvironmentAttributes] + if source != nil { + var modelsBaseEntity models.BaseEntity[models.ServingEnvironmentAttributes] + var pString *string + if (*source).Model != nil { + pString = (*source).Model.Id + } + if pString != nil { + xint32, err := converter.StringToInt32(*pString) + if err != nil { + return nil, fmt.Errorf("error setting field ID: %w", err) + } + modelsBaseEntity.ID = &xint32 + } + pInt32, err := converter.MapServingEnvironmentTypeIDEmbedMD(source) + if err != nil { + return nil, fmt.Errorf("error setting field TypeID: %w", err) + } + modelsBaseEntity.TypeID = pInt32 + pModelsServingEnvironmentAttributes, err := converter.MapServingEnvironmentAttributesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Attributes: %w", err) + } + modelsBaseEntity.Attributes = pModelsServingEnvironmentAttributes + pModelsPropertiesList, err := converter.MapServingEnvironmentPropertiesEmbedMD((*source).Model) + if err != nil { + return nil, fmt.Errorf("error setting field Properties: %w", err) + } + modelsBaseEntity.Properties = pModelsPropertiesList + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if (*source).Model != nil { + pMapStringOpenapiMetadataValue = (*source).Model.CustomProperties + } + pModelsPropertiesList2, err := converter.MapOpenAPICustomPropertiesEmbedMD(pMapStringOpenapiMetadataValue) + if err != nil { + return nil, fmt.Errorf("error setting field CustomProperties: %w", err) + } + modelsBaseEntity.CustomProperties = pModelsPropertiesList2 + pModelsBaseEntity = &modelsBaseEntity + } + return pModelsBaseEntity, nil +} diff --git a/internal/converter/generated/openapi_reconciler.gen.go b/internal/converter/generated/openapi_reconciler.gen.go new file mode 100644 index 000000000..0b9e3d591 --- /dev/null +++ b/internal/converter/generated/openapi_reconciler.gen.go @@ -0,0 +1,1177 @@ +// Code generated by github.com/jmattheis/goverter, DO NOT EDIT. +//go:build !goverter + +package generated + +import ( + "fmt" + converter "github.com/kubeflow/model-registry/internal/converter" + openapi "github.com/kubeflow/model-registry/pkg/openapi" +) + +type OpenAPIReconcilerImpl struct{} + +func (c *OpenAPIReconcilerImpl) UpdateExistingDataSet(source converter.OpenapiUpdateWrapper[openapi.DataSet]) (openapi.DataSet, error) { + openapiDataSet := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiDataSet.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiDataSet.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiDataSet.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.ExperimentId + } + if pString3 != nil { + xstring3 := *pString3 + openapiDataSet.ExperimentId = &xstring3 + } + var pString4 *string + if source.Update != nil { + pString4 = source.Update.ExperimentRunId + } + if pString4 != nil { + xstring4 := *pString4 + openapiDataSet.ExperimentRunId = &xstring4 + } + var pString5 *string + if source.Update != nil { + pString5 = source.Update.Digest + } + if pString5 != nil { + xstring5 := *pString5 + openapiDataSet.Digest = &xstring5 + } + var pString6 *string + if source.Update != nil { + pString6 = source.Update.SourceType + } + if pString6 != nil { + xstring6 := *pString6 + openapiDataSet.SourceType = &xstring6 + } + var pString7 *string + if source.Update != nil { + pString7 = source.Update.Source + } + if pString7 != nil { + xstring7 := *pString7 + openapiDataSet.Source = &xstring7 + } + var pString8 *string + if source.Update != nil { + pString8 = source.Update.Schema + } + if pString8 != nil { + xstring8 := *pString8 + openapiDataSet.Schema = &xstring8 + } + var pString9 *string + if source.Update != nil { + pString9 = source.Update.Profile + } + if pString9 != nil { + xstring9 := *pString9 + openapiDataSet.Profile = &xstring9 + } + var pString10 *string + if source.Update != nil { + pString10 = source.Update.Uri + } + if pString10 != nil { + xstring10 := *pString10 + openapiDataSet.Uri = &xstring10 + } + var pOpenapiArtifactState *openapi.ArtifactState + if source.Update != nil { + pOpenapiArtifactState = source.Update.State + } + if pOpenapiArtifactState != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*pOpenapiArtifactState) + if err != nil { + return openapiDataSet, fmt.Errorf("error setting field State: %w", err) + } + openapiDataSet.State = &openapiArtifactState + } + return openapiDataSet, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingDocArtifact(source converter.OpenapiUpdateWrapper[openapi.DocArtifact]) (openapi.DocArtifact, error) { + openapiDocArtifact := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiDocArtifact.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiDocArtifact.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiDocArtifact.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.ExperimentId + } + if pString3 != nil { + xstring3 := *pString3 + openapiDocArtifact.ExperimentId = &xstring3 + } + var pString4 *string + if source.Update != nil { + pString4 = source.Update.ExperimentRunId + } + if pString4 != nil { + xstring4 := *pString4 + openapiDocArtifact.ExperimentRunId = &xstring4 + } + var pString5 *string + if source.Update != nil { + pString5 = source.Update.Uri + } + if pString5 != nil { + xstring5 := *pString5 + openapiDocArtifact.Uri = &xstring5 + } + var pOpenapiArtifactState *openapi.ArtifactState + if source.Update != nil { + pOpenapiArtifactState = source.Update.State + } + if pOpenapiArtifactState != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*pOpenapiArtifactState) + if err != nil { + return openapiDocArtifact, fmt.Errorf("error setting field State: %w", err) + } + openapiDocArtifact.State = &openapiArtifactState + } + return openapiDocArtifact, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingExperiment(source converter.OpenapiUpdateWrapper[openapi.Experiment]) (openapi.Experiment, error) { + openapiExperiment := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiExperiment.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiExperiment.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiExperiment.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.Owner + } + if pString3 != nil { + xstring3 := *pString3 + openapiExperiment.Owner = &xstring3 + } + var pOpenapiExperimentState *openapi.ExperimentState + if source.Update != nil { + pOpenapiExperimentState = source.Update.State + } + if pOpenapiExperimentState != nil { + openapiExperimentState, err := c.openapiExperimentStateToOpenapiExperimentState(*pOpenapiExperimentState) + if err != nil { + return openapiExperiment, fmt.Errorf("error setting field State: %w", err) + } + openapiExperiment.State = &openapiExperimentState + } + return openapiExperiment, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingExperimentRun(source converter.OpenapiUpdateWrapper[openapi.ExperimentRun]) (openapi.ExperimentRun, error) { + openapiExperimentRun := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiExperimentRun.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiExperimentRun.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiExperimentRun.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.EndTimeSinceEpoch + } + if pString3 != nil { + xstring3 := *pString3 + openapiExperimentRun.EndTimeSinceEpoch = &xstring3 + } + var pOpenapiExperimentRunStatus *openapi.ExperimentRunStatus + if source.Update != nil { + pOpenapiExperimentRunStatus = source.Update.Status + } + if pOpenapiExperimentRunStatus != nil { + openapiExperimentRunStatus, err := c.openapiExperimentRunStatusToOpenapiExperimentRunStatus(*pOpenapiExperimentRunStatus) + if err != nil { + return openapiExperimentRun, fmt.Errorf("error setting field Status: %w", err) + } + openapiExperimentRun.Status = &openapiExperimentRunStatus + } + var pOpenapiExperimentRunState *openapi.ExperimentRunState + if source.Update != nil { + pOpenapiExperimentRunState = source.Update.State + } + if pOpenapiExperimentRunState != nil { + openapiExperimentRunState, err := c.openapiExperimentRunStateToOpenapiExperimentRunState(*pOpenapiExperimentRunState) + if err != nil { + return openapiExperimentRun, fmt.Errorf("error setting field State: %w", err) + } + openapiExperimentRun.State = &openapiExperimentRunState + } + var pString4 *string + if source.Update != nil { + pString4 = source.Update.Owner + } + if pString4 != nil { + xstring4 := *pString4 + openapiExperimentRun.Owner = &xstring4 + } + var pString5 *string + if source.Update != nil { + pString5 = source.Update.StartTimeSinceEpoch + } + if pString5 != nil { + xstring5 := *pString5 + openapiExperimentRun.StartTimeSinceEpoch = &xstring5 + } + return openapiExperimentRun, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingInferenceService(source converter.OpenapiUpdateWrapper[openapi.InferenceService]) (openapi.InferenceService, error) { + openapiInferenceService := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiInferenceService.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiInferenceService.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiInferenceService.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.ModelVersionId + } + if pString3 != nil { + xstring3 := *pString3 + openapiInferenceService.ModelVersionId = &xstring3 + } + var pString4 *string + if source.Update != nil { + pString4 = source.Update.Runtime + } + if pString4 != nil { + xstring4 := *pString4 + openapiInferenceService.Runtime = &xstring4 + } + var pOpenapiInferenceServiceState *openapi.InferenceServiceState + if source.Update != nil { + pOpenapiInferenceServiceState = source.Update.DesiredState + } + if pOpenapiInferenceServiceState != nil { + openapiInferenceServiceState, err := c.openapiInferenceServiceStateToOpenapiInferenceServiceState(*pOpenapiInferenceServiceState) + if err != nil { + return openapiInferenceService, fmt.Errorf("error setting field DesiredState: %w", err) + } + openapiInferenceService.DesiredState = &openapiInferenceServiceState + } + return openapiInferenceService, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingMetric(source converter.OpenapiUpdateWrapper[openapi.Metric]) (openapi.Metric, error) { + openapiMetric := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiMetric.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiMetric.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiMetric.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.ExperimentId + } + if pString3 != nil { + xstring3 := *pString3 + openapiMetric.ExperimentId = &xstring3 + } + var pString4 *string + if source.Update != nil { + pString4 = source.Update.ExperimentRunId + } + if pString4 != nil { + xstring4 := *pString4 + openapiMetric.ExperimentRunId = &xstring4 + } + var pFloat64 *float64 + if source.Update != nil { + pFloat64 = source.Update.Value + } + if pFloat64 != nil { + xfloat64 := *pFloat64 + openapiMetric.Value = &xfloat64 + } + var pString5 *string + if source.Update != nil { + pString5 = source.Update.Timestamp + } + if pString5 != nil { + xstring5 := *pString5 + openapiMetric.Timestamp = &xstring5 + } + var pInt64 *int64 + if source.Update != nil { + pInt64 = source.Update.Step + } + if pInt64 != nil { + xint64 := *pInt64 + openapiMetric.Step = &xint64 + } + var pOpenapiArtifactState *openapi.ArtifactState + if source.Update != nil { + pOpenapiArtifactState = source.Update.State + } + if pOpenapiArtifactState != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*pOpenapiArtifactState) + if err != nil { + return openapiMetric, fmt.Errorf("error setting field State: %w", err) + } + openapiMetric.State = &openapiArtifactState + } + return openapiMetric, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingModelArtifact(source converter.OpenapiUpdateWrapper[openapi.ModelArtifact]) (openapi.ModelArtifact, error) { + openapiModelArtifact := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiModelArtifact.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiModelArtifact.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiModelArtifact.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.ExperimentId + } + if pString3 != nil { + xstring3 := *pString3 + openapiModelArtifact.ExperimentId = &xstring3 + } + var pString4 *string + if source.Update != nil { + pString4 = source.Update.ExperimentRunId + } + if pString4 != nil { + xstring4 := *pString4 + openapiModelArtifact.ExperimentRunId = &xstring4 + } + var pString5 *string + if source.Update != nil { + pString5 = source.Update.ModelFormatName + } + if pString5 != nil { + xstring5 := *pString5 + openapiModelArtifact.ModelFormatName = &xstring5 + } + var pString6 *string + if source.Update != nil { + pString6 = source.Update.StorageKey + } + if pString6 != nil { + xstring6 := *pString6 + openapiModelArtifact.StorageKey = &xstring6 + } + var pString7 *string + if source.Update != nil { + pString7 = source.Update.StoragePath + } + if pString7 != nil { + xstring7 := *pString7 + openapiModelArtifact.StoragePath = &xstring7 + } + var pString8 *string + if source.Update != nil { + pString8 = source.Update.ModelFormatVersion + } + if pString8 != nil { + xstring8 := *pString8 + openapiModelArtifact.ModelFormatVersion = &xstring8 + } + var pString9 *string + if source.Update != nil { + pString9 = source.Update.ServiceAccountName + } + if pString9 != nil { + xstring9 := *pString9 + openapiModelArtifact.ServiceAccountName = &xstring9 + } + var pString10 *string + if source.Update != nil { + pString10 = source.Update.ModelSourceKind + } + if pString10 != nil { + xstring10 := *pString10 + openapiModelArtifact.ModelSourceKind = &xstring10 + } + var pString11 *string + if source.Update != nil { + pString11 = source.Update.ModelSourceClass + } + if pString11 != nil { + xstring11 := *pString11 + openapiModelArtifact.ModelSourceClass = &xstring11 + } + var pString12 *string + if source.Update != nil { + pString12 = source.Update.ModelSourceGroup + } + if pString12 != nil { + xstring12 := *pString12 + openapiModelArtifact.ModelSourceGroup = &xstring12 + } + var pString13 *string + if source.Update != nil { + pString13 = source.Update.ModelSourceId + } + if pString13 != nil { + xstring13 := *pString13 + openapiModelArtifact.ModelSourceId = &xstring13 + } + var pString14 *string + if source.Update != nil { + pString14 = source.Update.ModelSourceName + } + if pString14 != nil { + xstring14 := *pString14 + openapiModelArtifact.ModelSourceName = &xstring14 + } + var pString15 *string + if source.Update != nil { + pString15 = source.Update.Uri + } + if pString15 != nil { + xstring15 := *pString15 + openapiModelArtifact.Uri = &xstring15 + } + var pOpenapiArtifactState *openapi.ArtifactState + if source.Update != nil { + pOpenapiArtifactState = source.Update.State + } + if pOpenapiArtifactState != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*pOpenapiArtifactState) + if err != nil { + return openapiModelArtifact, fmt.Errorf("error setting field State: %w", err) + } + openapiModelArtifact.State = &openapiArtifactState + } + return openapiModelArtifact, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingModelVersion(source converter.OpenapiUpdateWrapper[openapi.ModelVersion]) (openapi.ModelVersion, error) { + openapiModelVersion := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiModelVersion.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiModelVersion.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiModelVersion.ExternalId = &xstring2 + } + var pOpenapiModelVersionState *openapi.ModelVersionState + if source.Update != nil { + pOpenapiModelVersionState = source.Update.State + } + if pOpenapiModelVersionState != nil { + openapiModelVersionState, err := c.openapiModelVersionStateToOpenapiModelVersionState(*pOpenapiModelVersionState) + if err != nil { + return openapiModelVersion, fmt.Errorf("error setting field State: %w", err) + } + openapiModelVersion.State = &openapiModelVersionState + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.Author + } + if pString3 != nil { + xstring3 := *pString3 + openapiModelVersion.Author = &xstring3 + } + return openapiModelVersion, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingParameter(source converter.OpenapiUpdateWrapper[openapi.Parameter]) (openapi.Parameter, error) { + openapiParameter := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiParameter.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiParameter.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiParameter.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.ExperimentId + } + if pString3 != nil { + xstring3 := *pString3 + openapiParameter.ExperimentId = &xstring3 + } + var pString4 *string + if source.Update != nil { + pString4 = source.Update.ExperimentRunId + } + if pString4 != nil { + xstring4 := *pString4 + openapiParameter.ExperimentRunId = &xstring4 + } + var pString5 *string + if source.Update != nil { + pString5 = source.Update.Value + } + if pString5 != nil { + xstring5 := *pString5 + openapiParameter.Value = &xstring5 + } + var pOpenapiParameterType *openapi.ParameterType + if source.Update != nil { + pOpenapiParameterType = source.Update.ParameterType + } + if pOpenapiParameterType != nil { + openapiParameterType, err := c.openapiParameterTypeToOpenapiParameterType(*pOpenapiParameterType) + if err != nil { + return openapiParameter, fmt.Errorf("error setting field ParameterType: %w", err) + } + openapiParameter.ParameterType = &openapiParameterType + } + var pOpenapiArtifactState *openapi.ArtifactState + if source.Update != nil { + pOpenapiArtifactState = source.Update.State + } + if pOpenapiArtifactState != nil { + openapiArtifactState, err := c.openapiArtifactStateToOpenapiArtifactState(*pOpenapiArtifactState) + if err != nil { + return openapiParameter, fmt.Errorf("error setting field State: %w", err) + } + openapiParameter.State = &openapiArtifactState + } + return openapiParameter, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingRegisteredModel(source converter.OpenapiUpdateWrapper[openapi.RegisteredModel]) (openapi.RegisteredModel, error) { + openapiRegisteredModel := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiRegisteredModel.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiRegisteredModel.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiRegisteredModel.ExternalId = &xstring2 + } + var pString3 *string + if source.Update != nil { + pString3 = source.Update.Readme + } + if pString3 != nil { + xstring3 := *pString3 + openapiRegisteredModel.Readme = &xstring3 + } + var pString4 *string + if source.Update != nil { + pString4 = source.Update.Maturity + } + if pString4 != nil { + xstring4 := *pString4 + openapiRegisteredModel.Maturity = &xstring4 + } + var pStringList *[]string + if source.Update != nil { + pStringList = &source.Update.Language + } + if pStringList != nil { + var stringList []string + if (*pStringList) != nil { + stringList = make([]string, len((*pStringList))) + for i := 0; i < len((*pStringList)); i++ { + stringList[i] = (*pStringList)[i] + } + } + openapiRegisteredModel.Language = stringList + } + var pStringList2 *[]string + if source.Update != nil { + pStringList2 = &source.Update.Tasks + } + if pStringList2 != nil { + var stringList2 []string + if (*pStringList2) != nil { + stringList2 = make([]string, len((*pStringList2))) + for j := 0; j < len((*pStringList2)); j++ { + stringList2[j] = (*pStringList2)[j] + } + } + openapiRegisteredModel.Tasks = stringList2 + } + var pString5 *string + if source.Update != nil { + pString5 = source.Update.Provider + } + if pString5 != nil { + xstring5 := *pString5 + openapiRegisteredModel.Provider = &xstring5 + } + var pString6 *string + if source.Update != nil { + pString6 = source.Update.Logo + } + if pString6 != nil { + xstring6 := *pString6 + openapiRegisteredModel.Logo = &xstring6 + } + var pString7 *string + if source.Update != nil { + pString7 = source.Update.License + } + if pString7 != nil { + xstring7 := *pString7 + openapiRegisteredModel.License = &xstring7 + } + var pString8 *string + if source.Update != nil { + pString8 = source.Update.LicenseLink + } + if pString8 != nil { + xstring8 := *pString8 + openapiRegisteredModel.LicenseLink = &xstring8 + } + var pString9 *string + if source.Update != nil { + pString9 = source.Update.LibraryName + } + if pString9 != nil { + xstring9 := *pString9 + openapiRegisteredModel.LibraryName = &xstring9 + } + var pString10 *string + if source.Update != nil { + pString10 = source.Update.Owner + } + if pString10 != nil { + xstring10 := *pString10 + openapiRegisteredModel.Owner = &xstring10 + } + var pOpenapiRegisteredModelState *openapi.RegisteredModelState + if source.Update != nil { + pOpenapiRegisteredModelState = source.Update.State + } + if pOpenapiRegisteredModelState != nil { + openapiRegisteredModelState, err := c.openapiRegisteredModelStateToOpenapiRegisteredModelState(*pOpenapiRegisteredModelState) + if err != nil { + return openapiRegisteredModel, fmt.Errorf("error setting field State: %w", err) + } + openapiRegisteredModel.State = &openapiRegisteredModelState + } + return openapiRegisteredModel, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingServeModel(source converter.OpenapiUpdateWrapper[openapi.ServeModel]) (openapi.ServeModel, error) { + openapiServeModel := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiServeModel.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiServeModel.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiServeModel.ExternalId = &xstring2 + } + var pOpenapiExecutionState *openapi.ExecutionState + if source.Update != nil { + pOpenapiExecutionState = source.Update.LastKnownState + } + if pOpenapiExecutionState != nil { + openapiExecutionState, err := c.openapiExecutionStateToOpenapiExecutionState(*pOpenapiExecutionState) + if err != nil { + return openapiServeModel, fmt.Errorf("error setting field LastKnownState: %w", err) + } + openapiServeModel.LastKnownState = &openapiExecutionState + } + return openapiServeModel, nil +} +func (c *OpenAPIReconcilerImpl) UpdateExistingServingEnvironment(source converter.OpenapiUpdateWrapper[openapi.ServingEnvironment]) (openapi.ServingEnvironment, error) { + openapiServingEnvironment := converter.InitWithExisting(source) + var pMapStringOpenapiMetadataValue *map[string]openapi.MetadataValue + if source.Update != nil { + pMapStringOpenapiMetadataValue = source.Update.CustomProperties + } + if pMapStringOpenapiMetadataValue != nil { + var mapStringOpenapiMetadataValue map[string]openapi.MetadataValue + if (*pMapStringOpenapiMetadataValue) != nil { + mapStringOpenapiMetadataValue = make(map[string]openapi.MetadataValue, len((*pMapStringOpenapiMetadataValue))) + for key, value := range *pMapStringOpenapiMetadataValue { + mapStringOpenapiMetadataValue[key] = c.openapiMetadataValueToOpenapiMetadataValue(value) + } + } + openapiServingEnvironment.CustomProperties = &mapStringOpenapiMetadataValue + } + var pString *string + if source.Update != nil { + pString = source.Update.Description + } + if pString != nil { + xstring := *pString + openapiServingEnvironment.Description = &xstring + } + var pString2 *string + if source.Update != nil { + pString2 = source.Update.ExternalId + } + if pString2 != nil { + xstring2 := *pString2 + openapiServingEnvironment.ExternalId = &xstring2 + } + return openapiServingEnvironment, nil +} +func (c *OpenAPIReconcilerImpl) openapiArtifactStateToOpenapiArtifactState(source openapi.ArtifactState) (openapi.ArtifactState, error) { + var openapiArtifactState openapi.ArtifactState + switch source { + case openapi.ARTIFACTSTATE_ABANDONED: + openapiArtifactState = openapi.ARTIFACTSTATE_ABANDONED + case openapi.ARTIFACTSTATE_DELETED: + openapiArtifactState = openapi.ARTIFACTSTATE_DELETED + case openapi.ARTIFACTSTATE_LIVE: + openapiArtifactState = openapi.ARTIFACTSTATE_LIVE + case openapi.ARTIFACTSTATE_MARKED_FOR_DELETION: + openapiArtifactState = openapi.ARTIFACTSTATE_MARKED_FOR_DELETION + case openapi.ARTIFACTSTATE_PENDING: + openapiArtifactState = openapi.ARTIFACTSTATE_PENDING + case openapi.ARTIFACTSTATE_REFERENCE: + openapiArtifactState = openapi.ARTIFACTSTATE_REFERENCE + case openapi.ARTIFACTSTATE_UNKNOWN: + openapiArtifactState = openapi.ARTIFACTSTATE_UNKNOWN + default: + return openapiArtifactState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiArtifactState, nil +} +func (c *OpenAPIReconcilerImpl) openapiExecutionStateToOpenapiExecutionState(source openapi.ExecutionState) (openapi.ExecutionState, error) { + var openapiExecutionState openapi.ExecutionState + switch source { + case openapi.EXECUTIONSTATE_CACHED: + openapiExecutionState = openapi.EXECUTIONSTATE_CACHED + case openapi.EXECUTIONSTATE_CANCELED: + openapiExecutionState = openapi.EXECUTIONSTATE_CANCELED + case openapi.EXECUTIONSTATE_COMPLETE: + openapiExecutionState = openapi.EXECUTIONSTATE_COMPLETE + case openapi.EXECUTIONSTATE_FAILED: + openapiExecutionState = openapi.EXECUTIONSTATE_FAILED + case openapi.EXECUTIONSTATE_NEW: + openapiExecutionState = openapi.EXECUTIONSTATE_NEW + case openapi.EXECUTIONSTATE_RUNNING: + openapiExecutionState = openapi.EXECUTIONSTATE_RUNNING + case openapi.EXECUTIONSTATE_UNKNOWN: + openapiExecutionState = openapi.EXECUTIONSTATE_UNKNOWN + default: + return openapiExecutionState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiExecutionState, nil +} +func (c *OpenAPIReconcilerImpl) openapiExperimentRunStateToOpenapiExperimentRunState(source openapi.ExperimentRunState) (openapi.ExperimentRunState, error) { + var openapiExperimentRunState openapi.ExperimentRunState + switch source { + case openapi.EXPERIMENTRUNSTATE_ARCHIVED: + openapiExperimentRunState = openapi.EXPERIMENTRUNSTATE_ARCHIVED + case openapi.EXPERIMENTRUNSTATE_LIVE: + openapiExperimentRunState = openapi.EXPERIMENTRUNSTATE_LIVE + default: + return openapiExperimentRunState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiExperimentRunState, nil +} +func (c *OpenAPIReconcilerImpl) openapiExperimentRunStatusToOpenapiExperimentRunStatus(source openapi.ExperimentRunStatus) (openapi.ExperimentRunStatus, error) { + var openapiExperimentRunStatus openapi.ExperimentRunStatus + switch source { + case openapi.EXPERIMENTRUNSTATUS_FAILED: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_FAILED + case openapi.EXPERIMENTRUNSTATUS_FINISHED: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_FINISHED + case openapi.EXPERIMENTRUNSTATUS_KILLED: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_KILLED + case openapi.EXPERIMENTRUNSTATUS_RUNNING: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_RUNNING + case openapi.EXPERIMENTRUNSTATUS_SCHEDULED: + openapiExperimentRunStatus = openapi.EXPERIMENTRUNSTATUS_SCHEDULED + default: + return openapiExperimentRunStatus, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiExperimentRunStatus, nil +} +func (c *OpenAPIReconcilerImpl) openapiExperimentStateToOpenapiExperimentState(source openapi.ExperimentState) (openapi.ExperimentState, error) { + var openapiExperimentState openapi.ExperimentState + switch source { + case openapi.EXPERIMENTSTATE_ARCHIVED: + openapiExperimentState = openapi.EXPERIMENTSTATE_ARCHIVED + case openapi.EXPERIMENTSTATE_LIVE: + openapiExperimentState = openapi.EXPERIMENTSTATE_LIVE + default: + return openapiExperimentState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiExperimentState, nil +} +func (c *OpenAPIReconcilerImpl) openapiInferenceServiceStateToOpenapiInferenceServiceState(source openapi.InferenceServiceState) (openapi.InferenceServiceState, error) { + var openapiInferenceServiceState openapi.InferenceServiceState + switch source { + case openapi.INFERENCESERVICESTATE_DEPLOYED: + openapiInferenceServiceState = openapi.INFERENCESERVICESTATE_DEPLOYED + case openapi.INFERENCESERVICESTATE_UNDEPLOYED: + openapiInferenceServiceState = openapi.INFERENCESERVICESTATE_UNDEPLOYED + default: + return openapiInferenceServiceState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiInferenceServiceState, nil +} +func (c *OpenAPIReconcilerImpl) openapiMetadataValueToOpenapiMetadataValue(source openapi.MetadataValue) openapi.MetadataValue { + var openapiMetadataValue openapi.MetadataValue + openapiMetadataValue.MetadataBoolValue = c.pOpenapiMetadataBoolValueToPOpenapiMetadataBoolValue(source.MetadataBoolValue) + openapiMetadataValue.MetadataDoubleValue = c.pOpenapiMetadataDoubleValueToPOpenapiMetadataDoubleValue(source.MetadataDoubleValue) + openapiMetadataValue.MetadataIntValue = c.pOpenapiMetadataIntValueToPOpenapiMetadataIntValue(source.MetadataIntValue) + openapiMetadataValue.MetadataProtoValue = c.pOpenapiMetadataProtoValueToPOpenapiMetadataProtoValue(source.MetadataProtoValue) + openapiMetadataValue.MetadataStringValue = c.pOpenapiMetadataStringValueToPOpenapiMetadataStringValue(source.MetadataStringValue) + openapiMetadataValue.MetadataStructValue = c.pOpenapiMetadataStructValueToPOpenapiMetadataStructValue(source.MetadataStructValue) + return openapiMetadataValue +} +func (c *OpenAPIReconcilerImpl) openapiModelVersionStateToOpenapiModelVersionState(source openapi.ModelVersionState) (openapi.ModelVersionState, error) { + var openapiModelVersionState openapi.ModelVersionState + switch source { + case openapi.MODELVERSIONSTATE_ARCHIVED: + openapiModelVersionState = openapi.MODELVERSIONSTATE_ARCHIVED + case openapi.MODELVERSIONSTATE_LIVE: + openapiModelVersionState = openapi.MODELVERSIONSTATE_LIVE + default: + return openapiModelVersionState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiModelVersionState, nil +} +func (c *OpenAPIReconcilerImpl) openapiParameterTypeToOpenapiParameterType(source openapi.ParameterType) (openapi.ParameterType, error) { + var openapiParameterType openapi.ParameterType + switch source { + case openapi.PARAMETERTYPE_BOOLEAN: + openapiParameterType = openapi.PARAMETERTYPE_BOOLEAN + case openapi.PARAMETERTYPE_NUMBER: + openapiParameterType = openapi.PARAMETERTYPE_NUMBER + case openapi.PARAMETERTYPE_OBJECT: + openapiParameterType = openapi.PARAMETERTYPE_OBJECT + case openapi.PARAMETERTYPE_STRING: + openapiParameterType = openapi.PARAMETERTYPE_STRING + default: + return openapiParameterType, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiParameterType, nil +} +func (c *OpenAPIReconcilerImpl) openapiRegisteredModelStateToOpenapiRegisteredModelState(source openapi.RegisteredModelState) (openapi.RegisteredModelState, error) { + var openapiRegisteredModelState openapi.RegisteredModelState + switch source { + case openapi.REGISTEREDMODELSTATE_ARCHIVED: + openapiRegisteredModelState = openapi.REGISTEREDMODELSTATE_ARCHIVED + case openapi.REGISTEREDMODELSTATE_LIVE: + openapiRegisteredModelState = openapi.REGISTEREDMODELSTATE_LIVE + default: + return openapiRegisteredModelState, fmt.Errorf("unexpected enum element: %v", source) + } + return openapiRegisteredModelState, nil +} +func (c *OpenAPIReconcilerImpl) pOpenapiMetadataBoolValueToPOpenapiMetadataBoolValue(source *openapi.MetadataBoolValue) *openapi.MetadataBoolValue { + var pOpenapiMetadataBoolValue *openapi.MetadataBoolValue + if source != nil { + var openapiMetadataBoolValue openapi.MetadataBoolValue + openapiMetadataBoolValue.BoolValue = (*source).BoolValue + openapiMetadataBoolValue.MetadataType = (*source).MetadataType + pOpenapiMetadataBoolValue = &openapiMetadataBoolValue + } + return pOpenapiMetadataBoolValue +} +func (c *OpenAPIReconcilerImpl) pOpenapiMetadataDoubleValueToPOpenapiMetadataDoubleValue(source *openapi.MetadataDoubleValue) *openapi.MetadataDoubleValue { + var pOpenapiMetadataDoubleValue *openapi.MetadataDoubleValue + if source != nil { + var openapiMetadataDoubleValue openapi.MetadataDoubleValue + openapiMetadataDoubleValue.DoubleValue = (*source).DoubleValue + openapiMetadataDoubleValue.MetadataType = (*source).MetadataType + pOpenapiMetadataDoubleValue = &openapiMetadataDoubleValue + } + return pOpenapiMetadataDoubleValue +} +func (c *OpenAPIReconcilerImpl) pOpenapiMetadataIntValueToPOpenapiMetadataIntValue(source *openapi.MetadataIntValue) *openapi.MetadataIntValue { + var pOpenapiMetadataIntValue *openapi.MetadataIntValue + if source != nil { + var openapiMetadataIntValue openapi.MetadataIntValue + openapiMetadataIntValue.IntValue = (*source).IntValue + openapiMetadataIntValue.MetadataType = (*source).MetadataType + pOpenapiMetadataIntValue = &openapiMetadataIntValue + } + return pOpenapiMetadataIntValue +} +func (c *OpenAPIReconcilerImpl) pOpenapiMetadataProtoValueToPOpenapiMetadataProtoValue(source *openapi.MetadataProtoValue) *openapi.MetadataProtoValue { + var pOpenapiMetadataProtoValue *openapi.MetadataProtoValue + if source != nil { + var openapiMetadataProtoValue openapi.MetadataProtoValue + openapiMetadataProtoValue.Type = (*source).Type + openapiMetadataProtoValue.ProtoValue = (*source).ProtoValue + openapiMetadataProtoValue.MetadataType = (*source).MetadataType + pOpenapiMetadataProtoValue = &openapiMetadataProtoValue + } + return pOpenapiMetadataProtoValue +} +func (c *OpenAPIReconcilerImpl) pOpenapiMetadataStringValueToPOpenapiMetadataStringValue(source *openapi.MetadataStringValue) *openapi.MetadataStringValue { + var pOpenapiMetadataStringValue *openapi.MetadataStringValue + if source != nil { + var openapiMetadataStringValue openapi.MetadataStringValue + openapiMetadataStringValue.StringValue = (*source).StringValue + openapiMetadataStringValue.MetadataType = (*source).MetadataType + pOpenapiMetadataStringValue = &openapiMetadataStringValue + } + return pOpenapiMetadataStringValue +} +func (c *OpenAPIReconcilerImpl) pOpenapiMetadataStructValueToPOpenapiMetadataStructValue(source *openapi.MetadataStructValue) *openapi.MetadataStructValue { + var pOpenapiMetadataStructValue *openapi.MetadataStructValue + if source != nil { + var openapiMetadataStructValue openapi.MetadataStructValue + openapiMetadataStructValue.StructValue = (*source).StructValue + openapiMetadataStructValue.MetadataType = (*source).MetadataType + pOpenapiMetadataStructValue = &openapiMetadataStructValue + } + return pOpenapiMetadataStructValue +}