diff --git a/pkg/utils/types.go b/pkg/utils/types.go new file mode 100644 index 00000000000..9ac1cdfd8a9 --- /dev/null +++ b/pkg/utils/types.go @@ -0,0 +1,9 @@ +package utils + +func Bool(b bool) *bool { + return &b +} + +func UInt64(u uint64) *uint64 { + return &u +} diff --git a/pkg/utils/types_test.go b/pkg/utils/types_test.go new file mode 100644 index 00000000000..d8b6b6f6d52 --- /dev/null +++ b/pkg/utils/types_test.go @@ -0,0 +1,24 @@ +package utils + +import ( + "testing" + "github.com/google/go-cmp/cmp" +) + +func TestBool(t *testing.T) { + input := true + expected := &input + result := Bool(input) + if diff := cmp.Diff(expected, result); diff != "" { + t.Errorf("Test %q unexpected result (-want +got): %v", t.Name(), diff) + } +} + +func TestUInt64(t *testing.T) { + input := uint64(63) + expected := &input + result := UInt64(input) + if diff := cmp.Diff(expected, result); diff != "" { + t.Errorf("Test %q unexpected result (-want +got): %v", t.Name(), diff) + } +} diff --git a/tools/tf2openapi/Makefile b/tools/tf2openapi/Makefile index 4fcb54ecb9c..0ddf9d9c207 100644 --- a/tools/tf2openapi/Makefile +++ b/tools/tf2openapi/Makefile @@ -4,7 +4,7 @@ TF_PROTO_OUT := generated # Run tests test: generate - go test ./types/... + go test ./types/... ./generator/... # Generate code generate: diff --git a/tools/tf2openapi/generator/generate.go b/tools/tf2openapi/generator/generate.go index 2eb8b28fccf..fc0f7ef1487 100644 --- a/tools/tf2openapi/generator/generate.go +++ b/tools/tf2openapi/generator/generate.go @@ -8,8 +8,8 @@ import ( ) const ( - defaultSigDefKey = "serving_default" - defaultTag = "serve" + DefaultSigDefKey = "serving_default" + DefaultTag = "serve" ) // Known error messages @@ -33,10 +33,10 @@ type Builder struct { func (b *Builder) Build() Generator { if b.Generator.sigDefKey == "" { - b.SetSigDefKey(defaultSigDefKey) + b.SetSigDefKey(DefaultSigDefKey) } if len(b.Generator.metaGraphTags) == 0 { - b.SetMetaGraphTags([]string{defaultTag}) + b.SetMetaGraphTags([]string{DefaultTag}) } return b.Generator } @@ -68,10 +68,10 @@ func (g *Generator) GenerateOpenAPI(model *pb.SavedModel) (string, error) { } json, marshallingErr := spec.MarshalJSON() if marshallingErr != nil { - return "", fmt.Errorf(UnmarshallableSpecError, marshallingErr.Error(), json) + panic(fmt.Errorf(UnmarshallableSpecError, marshallingErr.Error(), json)) } if validationErr := validateOpenAPI(json); validationErr != nil { - return "", validationErr + panic(validationErr) } return string(json), nil } diff --git a/tools/tf2openapi/generator/generate_test.go b/tools/tf2openapi/generator/generate_test.go new file mode 100644 index 00000000000..a0b29236e69 --- /dev/null +++ b/tools/tf2openapi/generator/generate_test.go @@ -0,0 +1,308 @@ +package generator + +import ( + "bytes" + "context" + "encoding/json" + "fmt" + "github.com/getkin/kin-openapi/openapi3" + "github.com/getkin/kin-openapi/openapi3filter" + "github.com/golang/protobuf/proto" + "github.com/kubeflow/kfserving/tools/tf2openapi/generated/framework" + pb "github.com/kubeflow/kfserving/tools/tf2openapi/generated/protobuf" + "github.com/kubeflow/kfserving/tools/tf2openapi/types" + "github.com/onsi/gomega" + "io/ioutil" + "net/http" + "path/filepath" + "testing" +) + +func TestGeneratorBuilderSpecifiedFields(t *testing.T) { + g := gomega.NewGomegaWithT(t) + builder := &Builder{} + builder.SetName("model") + builder.SetVersion("1") + builder.SetMetaGraphTags([]string{"tag"}) + builder.SetSigDefKey("sigDefKey") + generator := builder.Build() + expectedGenerator := Generator{ + name: "model", + version: "1", + metaGraphTags: []string{"tag"}, + sigDefKey: "sigDefKey", + } + g.Expect(generator).Should(gomega.Equal(expectedGenerator)) +} + +func TestGeneratorBuilderDefault(t *testing.T) { + g := gomega.NewGomegaWithT(t) + builder := &Builder{} + builder.SetName("model") + builder.SetVersion("1") + generator := builder.Build() + expectedGenerator := defaultGenerator() + g.Expect(generator).Should(gomega.Equal(expectedGenerator)) +} + +func TestGenerateOpenAPIConstructionErr(t *testing.T) { + g := gomega.NewGomegaWithT(t) + generator := defaultGenerator() + model := &pb.SavedModel{ + MetaGraphs: []*pb.MetaGraphDef{ + { + MetaInfoDef: &pb.MetaGraphDef_MetaInfoDef{ + Tags: []string{ + "serve", + }, + }, + SignatureDef: map[string]*pb.SignatureDef{ + "sigDefKey": { + MethodName: "tensorflow/serving/predict", + Inputs: map[string]*pb.TensorInfo{ + "inputTensorName": { + // Unsupported data type will err + Dtype: framework.DataType_DT_COMPLEX128, + TensorShape: &framework.TensorShapeProto{ + Dim: []*framework.TensorShapeProto_Dim{ + {Size: -1}, + {Size: 3}, + }, + UnknownRank: false, + }, + }, + }, + Outputs: map[string]*pb.TensorInfo{ + "outputTensorName": { + Dtype: framework.DataType_DT_INT8, + TensorShape: &framework.TensorShapeProto{ + Dim: []*framework.TensorShapeProto_Dim{ + {Size: -1}, + {Size: 3}, + }, + UnknownRank: false, + }, + }, + }, + }, + }, + }, + }, + } + _, specErr := generator.GenerateOpenAPI(model) + expectedErr := fmt.Sprintf(types.UnsupportedDataTypeError, "inputTensorName", "DT_COMPLEX128") + g.Expect(specErr).To(gomega.MatchError(expectedErr)) +} + +func TestGenerateOpenAPISpecGenerationErr(t *testing.T) { + g := gomega.NewGomegaWithT(t) + generator := defaultGenerator() + model := &pb.SavedModel{ + MetaGraphs: []*pb.MetaGraphDef{ + { + MetaInfoDef: &pb.MetaGraphDef_MetaInfoDef{ + Tags: []string{ + "serve", + }, + }, + SignatureDef: map[string]*pb.SignatureDef{ + "serving_default": { + MethodName: "tensorflow/serving/classify", + Inputs: map[string]*pb.TensorInfo{ + "inputTensorName": { + Dtype: framework.DataType_DT_INT8, + TensorShape: &framework.TensorShapeProto{ + Dim: []*framework.TensorShapeProto_Dim{ + {Size: -1}, + {Size: 3}, + }, + UnknownRank: false, + }, + }, + }, + Outputs: map[string]*pb.TensorInfo{ + "outputTensorName": { + Dtype: framework.DataType_DT_INT8, + TensorShape: &framework.TensorShapeProto{ + Dim: []*framework.TensorShapeProto_Dim{ + {Size: -1}, + {Size: 3}, + }, + UnknownRank: false, + }, + }, + }, + }, + }, + }, + }, + } + _, specErr := generator.GenerateOpenAPI(model) + expectedErr := fmt.Sprintf(SpecGenerationError, types.UnsupportedAPISchemaError) + g.Expect(specErr).To(gomega.MatchError(expectedErr)) +} + + +func TestGenerateOpenAPIForRowFmtMultipleTensors(t *testing.T) { + // model src: gs://kfserving-samples/models/tensorflow/flowers + g := gomega.NewGomegaWithT(t) + model := model(t, "TestRowFmtMultipleTensors") + generator := defaultGenerator() + spec, specErr := generator.GenerateOpenAPI(model) + g.Expect(specErr).Should(gomega.BeNil()) + + swagger := &openapi3.Swagger{} + g.Expect(json.Unmarshal([]byte(spec), &swagger)).To(gomega.Succeed()) + + expectedSpec := string(openAPI(t, "TestRowFmtMultipleTensors")) + expectedSwagger := &openapi3.Swagger{} + // remove any formatting from expectedSpec + buffer := new(bytes.Buffer) + if err := json.Compact(buffer, []byte(expectedSpec)); err != nil { + t.Fatal(err) + } + g.Expect(json.Unmarshal(buffer.Bytes(), &expectedSwagger)).To(gomega.Succeed()) + + // test equality, ignoring order in JSON arrays + instances := swagger.Components.RequestBodies["modelInput"].Value.Content.Get("application/json"). + Schema.Value.Properties["instances"].Value + expectedInstances := expectedSwagger.Components.RequestBodies["modelInput"].Value.Content. + Get("application/json").Schema.Value.Properties["instances"].Value + g.Expect(instances.Items.Value.Required).Should(gomega.Not(gomega.BeNil())) + g.Expect(instances.Items.Value.Required).To(gomega.ConsistOf(expectedInstances.Items.Value.Required)) + g.Expect(instances.Items.Value.AdditionalPropertiesAllowed).Should(gomega.Not(gomega.BeNil())) + g.Expect(instances.Items.Value.AdditionalPropertiesAllowed).Should(gomega.Equal(expectedInstances.Items.Value.AdditionalPropertiesAllowed)) + g.Expect(instances.Items.Value.Properties).Should(gomega.Equal(expectedInstances.Items.Value.Properties)) +} + +func TestGenerateOpenAPIForColFmtMultipleTensors(t *testing.T) { + g := gomega.NewGomegaWithT(t) + model := model(t, "TestColFmtMultipleTensors") + generator := defaultGenerator() + spec, specErr := generator.GenerateOpenAPI(model) + g.Expect(specErr).Should(gomega.BeNil()) + + swagger := &openapi3.Swagger{} + g.Expect(json.Unmarshal([]byte(spec), &swagger)).To(gomega.Succeed()) + + expectedSpec := string(openAPI(t, "TestColFmtMultipleTensors")) + expectedSwagger := &openapi3.Swagger{} + // remove any formatting from expectedSpec + buffer := new(bytes.Buffer) + if err := json.Compact(buffer, []byte(expectedSpec)); err != nil { + t.Fatal(err) + } + g.Expect(json.Unmarshal(buffer.Bytes(), &expectedSwagger)).To(gomega.Succeed()) + + // ignore order in JSON arrays + inputs := swagger.Components.RequestBodies["modelInput"].Value.Content.Get("application/json"). + Schema.Value.Properties["inputs"].Value + expectedInputs := expectedSwagger.Components.RequestBodies["modelInput"].Value.Content. + Get("application/json").Schema.Value.Properties["inputs"].Value + g.Expect(inputs.Required).Should(gomega.Not(gomega.BeNil())) + g.Expect(inputs.Required).To(gomega.ConsistOf(expectedInputs.Required)) + g.Expect(inputs.Properties).Should(gomega.Equal(expectedInputs.Properties)) + g.Expect(inputs.AdditionalPropertiesAllowed).Should(gomega.Equal(expectedInputs.AdditionalPropertiesAllowed)) +} + +func TestGenerateOpenAPIForVariousFmtsStrictly(t *testing.T) { + inputFmts := []struct { + name string + }{ + {"TestColFmtSingleTensor"}, {"TestColFmtScalar"}, {"TestRowFmtSingleTensor"}, + } + for _, fmt := range inputFmts { + g := gomega.NewGomegaWithT(t) + model := model(t, fmt.name) + generator := defaultGenerator() + spec, specErr := generator.GenerateOpenAPI(model) + expectedSpec := openAPI(t, fmt.name) + g.Expect(spec).Should(gomega.MatchJSON(expectedSpec)) + g.Expect(specErr).Should(gomega.BeNil()) + } +} + +func TestAcceptsValidTFServingInput(t *testing.T) { + inputFmts := []struct { + name string + }{ + {"TestColFmtSingleTensor"}, + {"TestColFmtScalar"}, + {"TestRowFmtSingleTensor"}, + {"TestColFmtMultipleTensors"}, + {"TestRowFmtMultipleTensors"}, + } + for _, fmt := range inputFmts { + g := gomega.NewGomegaWithT(t) + g.Expect(acceptsValidReq(t, fmt.name)).Should(gomega.BeNil()) + } +} + +func defaultGenerator() Generator { + return Generator{ + name: "model", + version: "1", + metaGraphTags: []string{DefaultTag}, + sigDefKey: DefaultSigDefKey, + } +} + +func model(t *testing.T, fName string) *pb.SavedModel { + model := &pb.SavedModel{} + fPath := filepath.Join("testdata", fName+".pb") + modelPb, err := ioutil.ReadFile(fPath) + if err != nil { + t.Fatalf("failed reading %s: %s", fPath, err) + } + if err := proto.Unmarshal(modelPb, model); err != nil { + t.Fatal("SavedModel not in expected format. May be corrupted: " + err.Error()) + } + return model +} + +func openAPI(t *testing.T, fName string) []byte { + fPath := filepath.Join("testdata", fName+".golden.json") + openAPI, err := ioutil.ReadFile(fPath) + if err != nil { + t.Fatalf("failed reading %s: %s", fPath, err) + } + return openAPI +} + +func acceptsValidReq(t *testing.T, fName string) error { + router := openapi3filter.NewRouter().WithSwagger(loadSwagger(t, fName)) + req, reqErr := http.NewRequest(http.MethodPost, "/v1/models/model/versions/1:predict", + bytes.NewReader(loadPayload(t, fName))) + if reqErr != nil { + t.Fatalf("error creating request: %s", reqErr) + } + route, pathParams, routeErr := router.FindRoute(req.Method, req.URL) + if routeErr != nil { + t.Fatalf("error finding route: %s", routeErr) + } + req.Header.Set("Content-Type", "application/json") + requestValidationInput := &openapi3filter.RequestValidationInput{ + Request: req, + PathParams: pathParams, + Route: route, + } + return openapi3filter.ValidateRequest(context.TODO(), requestValidationInput) +} + +func loadSwagger(t *testing.T, fName string) *openapi3.Swagger { + fPath := filepath.Join("testdata", fName+".golden.json") + swagger, err := openapi3.NewSwaggerLoader().LoadSwaggerFromFile(fPath) + if err != nil { + t.Fatalf("failed reading %s: %s", fPath, err) + } + return swagger +} + +func loadPayload(t *testing.T, fName string) []byte { + fPath := filepath.Join("testdata", fName+"Req.json") + payload, err := ioutil.ReadFile(fPath) + if err != nil { + t.Fatalf("failed reading %s: %s", fPath, err) + } + return payload +} diff --git a/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensors.golden.json b/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensors.golden.json new file mode 100644 index 00000000000..dbade093645 --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensors.golden.json @@ -0,0 +1,86 @@ +{ + "components": { + "requestBodies": { + "modelInput": { + "content": { + "application/json": { + "schema": { + "properties": { + "inputs": { + "properties": { + "b": { + "items": { + "items": { + "items": { + "type": "number" + }, + "maxItems": 2, + "minItems": 2, + "type": "array" + }, + "maxItems": 3, + "minItems": 3, + "type": "array" + }, + "maxItems": 2, + "minItems": 2, + "type": "array" + }, + "x": { + "items": { + "items": { + "items": { + "type": "number" + }, + "maxItems": 3, + "minItems": 3, + "type": "array" + }, + "maxItems": 2, + "minItems": 2, + "type": "array" + }, + "maxItems": 2, + "minItems": 2, + "type": "array" + } + }, + "required": ["x", "b"], + "additionalProperties": false, + "type": "object" + } + }, + "type": "object", + "required": ["inputs"], + "additionalProperties": false + } + } + } + } + }, + "responses": { + "modelOutput": { + "description": "Model output" + } + } + }, + "info": { + "title": "TFServing Predict Request API", + "version": "1.0" + }, + "openapi": "3.0.0", + "paths": { + "/v1/models/model/versions/1:predict": { + "post": { + "requestBody": { + "$ref": "#/components/requestBodies/modelInput" + }, + "responses": { + "200": { + "$ref": "#/components/responses/modelOutput" + } + } + } + } + } +} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensors.pb b/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensors.pb new file mode 100644 index 00000000000..1c0174c2fa6 Binary files /dev/null and b/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensors.pb differ diff --git a/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensorsReq.json b/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensorsReq.json new file mode 100644 index 00000000000..c04b301ad16 --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestColFmtMultipleTensorsReq.json @@ -0,0 +1,26 @@ +{ + "inputs": { + "x": [ + [ + [1, 2, 3], + [4, 5, 6] + ], + [ + [7, 8, 9], + [10, 11, 12] + ] + ], + "b": [ + [ + [13, 14], + [15, 16], + [17, 18] + ], + [ + [19, 20], + [21, 22], + [23, 24] + ] + ] + } +} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestColFmtScalar.golden.json b/tools/tf2openapi/generator/testdata/TestColFmtScalar.golden.json new file mode 100644 index 00000000000..b5852a4d0fa --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestColFmtScalar.golden.json @@ -0,0 +1,44 @@ +{ + "components": { + "requestBodies": { + "modelInput": { + "content": { + "application/json": { + "schema": { + "properties": { + "inputs": {} + }, + "type": "object", + "required": ["inputs"], + "additionalProperties": false + } + } + } + } + }, + "responses": { + "modelOutput": { + "description": "Model output" + } + } + }, + "info": { + "title": "TFServing Predict Request API", + "version": "1.0" + }, + "openapi": "3.0.0", + "paths": { + "/v1/models/model/versions/1:predict": { + "post": { + "requestBody": { + "$ref": "#/components/requestBodies/modelInput" + }, + "responses": { + "200": { + "$ref": "#/components/responses/modelOutput" + } + } + } + } + } +} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestColFmtScalar.pb b/tools/tf2openapi/generator/testdata/TestColFmtScalar.pb new file mode 100644 index 00000000000..6168a58c18c Binary files /dev/null and b/tools/tf2openapi/generator/testdata/TestColFmtScalar.pb differ diff --git a/tools/tf2openapi/generator/testdata/TestColFmtScalarReq.json b/tools/tf2openapi/generator/testdata/TestColFmtScalarReq.json new file mode 100644 index 00000000000..f60726c9ffe --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestColFmtScalarReq.json @@ -0,0 +1,3 @@ +{ + "inputs": 1 +} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestColFmtSingleTensor.golden.json b/tools/tf2openapi/generator/testdata/TestColFmtSingleTensor.golden.json new file mode 100644 index 00000000000..2e50d984d23 --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestColFmtSingleTensor.golden.json @@ -0,0 +1,56 @@ +{ + "components": { + "requestBodies": { + "modelInput": { + "content": { + "application/json": { + "schema": { + "properties": { + "inputs": { + "items": { + "items": { + "type": "number" + }, + "maxItems": 3, + "minItems": 3, + "type": "array" + }, + "maxItems": 3, + "minItems": 3, + "type": "array" + } + }, + "type": "object", + "required": ["inputs"], + "additionalProperties": false + } + } + } + } + }, + "responses": { + "modelOutput": { + "description": "Model output" + } + } + }, + "info": { + "title": "TFServing Predict Request API", + "version": "1.0" + }, + "openapi": "3.0.0", + "paths": { + "/v1/models/model/versions/1:predict": { + "post": { + "requestBody": { + "$ref": "#/components/requestBodies/modelInput" + }, + "responses": { + "200": { + "$ref": "#/components/responses/modelOutput" + } + } + } + } + } +} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestColFmtSingleTensor.pb b/tools/tf2openapi/generator/testdata/TestColFmtSingleTensor.pb new file mode 100644 index 00000000000..975d4c93941 Binary files /dev/null and b/tools/tf2openapi/generator/testdata/TestColFmtSingleTensor.pb differ diff --git a/tools/tf2openapi/generator/testdata/TestColFmtSingleTensorReq.json b/tools/tf2openapi/generator/testdata/TestColFmtSingleTensorReq.json new file mode 100644 index 00000000000..48022569538 --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestColFmtSingleTensorReq.json @@ -0,0 +1 @@ +{"inputs": [[1, 2, 5],[6,7,8],[9,0,3]]} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensors.golden.json b/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensors.golden.json new file mode 100644 index 00000000000..bde5275954c --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensors.golden.json @@ -0,0 +1,64 @@ +{ + "components": { + "requestBodies": { + "modelInput": { + "content": { + "application/json": { + "schema": { + "properties": { + "instances": { + "items": { + "properties": { + "image_bytes": { + "properties": { + "b64": { + "type": "string" + } + }, + "type": "object" + }, + "key": { + "type": "string" + } + }, + "required": ["key", "image_bytes"], + "additionalProperties": false, + "type": "object" + }, + "type": "array" + } + }, + "required": ["instances"], + "additionalProperties": false, + "type": "object" + } + } + } + } + }, + "responses": { + "modelOutput": { + "description": "Model output" + } + } + }, + "info": { + "title": "TFServing Predict Request API", + "version": "1.0" + }, + "openapi": "3.0.0", + "paths": { + "/v1/models/model/versions/1:predict": { + "post": { + "requestBody": { + "$ref": "#/components/requestBodies/modelInput" + }, + "responses": { + "200": { + "$ref": "#/components/responses/modelOutput" + } + } + } + } + } +} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensors.pb b/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensors.pb new file mode 100644 index 00000000000..c7aaf5b946a Binary files /dev/null and b/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensors.pb differ diff --git a/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensorsReq.json b/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensorsReq.json new file mode 100644 index 00000000000..36f8d37c65a --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestRowFmtMultipleTensorsReq.json @@ -0,0 +1,16 @@ +{ + "instances":[ + { + "image_bytes":{ + "b64":"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" + }, + "key":" 1" + }, + { + "image_bytes":{ + "b64":"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" + }, + "key":" 1" + } + ] +} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensor.golden.json b/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensor.golden.json new file mode 100644 index 00000000000..6e3503f176a --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensor.golden.json @@ -0,0 +1,54 @@ +{ + "components": { + "requestBodies": { + "modelInput": { + "content": { + "application/json": { + "schema": { + "properties": { + "instances": { + "items": { + "items": { + "type": "number" + }, + "maxItems": 4, + "minItems": 4, + "type": "array" + }, + "type": "array" + } + }, + "type": "object", + "required": ["instances"], + "additionalProperties": false + } + } + } + } + }, + "responses": { + "modelOutput": { + "description": "Model output" + } + } + }, + "info": { + "title": "TFServing Predict Request API", + "version": "1.0" + }, + "openapi": "3.0.0", + "paths": { + "/v1/models/model/versions/1:predict": { + "post": { + "requestBody": { + "$ref": "#/components/requestBodies/modelInput" + }, + "responses": { + "200": { + "$ref": "#/components/responses/modelOutput" + } + } + } + } + } +} \ No newline at end of file diff --git a/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensor.pb b/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensor.pb new file mode 100644 index 00000000000..2b4ca511fa4 Binary files /dev/null and b/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensor.pb differ diff --git a/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensorReq.json b/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensorReq.json new file mode 100644 index 00000000000..3a890867f5a --- /dev/null +++ b/tools/tf2openapi/generator/testdata/TestRowFmtSingleTensorReq.json @@ -0,0 +1,10 @@ +{ + "instances": [ + [ + 1, + 2, + 3, + 4 + ] + ] +} \ No newline at end of file diff --git a/tools/tf2openapi/types/tfmetagraph_test.go b/tools/tf2openapi/types/tfmetagraph_test.go index a7fa2dbbb2e..162be0247f2 100644 --- a/tools/tf2openapi/types/tfmetagraph_test.go +++ b/tools/tf2openapi/types/tfmetagraph_test.go @@ -217,6 +217,8 @@ func TestTFMetaGraphTypical(t *testing.T) { }, }, }, + Required: []string{"instances"}, + AdditionalPropertiesAllowed: func(b bool) *bool {return &b}(false), } schema, err := tfMetaGraph.Schema("sigDefKey") g.Expect(schema).Should(gomega.Equal(expectedSchema)) diff --git a/tools/tf2openapi/types/tfsavedmodel_test.go b/tools/tf2openapi/types/tfsavedmodel_test.go index 3a881d39359..e093f67f94a 100644 --- a/tools/tf2openapi/types/tfsavedmodel_test.go +++ b/tools/tf2openapi/types/tfsavedmodel_test.go @@ -127,6 +127,8 @@ func TestTFSavedModelTypical(t *testing.T) { }, }, }, + Required: []string{"instances"}, + AdditionalPropertiesAllowed: func(b bool) *bool {return &b}(false), } schema, err := tfSavedModel.Schema([]string{"serve"}, "sigDefKey") g.Expect(schema).Should(gomega.Equal(expectedSchema)) diff --git a/tools/tf2openapi/types/tfsignaturedef.go b/tools/tf2openapi/types/tfsignaturedef.go index 9b5d95fff67..9bbda96f91b 100644 --- a/tools/tf2openapi/types/tfsignaturedef.go +++ b/tools/tf2openapi/types/tfsignaturedef.go @@ -84,11 +84,25 @@ func (t *TFSignatureDef) Schema() (*openapi3.Schema, error) { } // https://www.tensorflow.org/tfx/serving/api_rest#specifying_input_tensors_in_row_format if canHaveRowSchema(t.Inputs) { - return openapi3.NewObjectSchema().WithProperty("instances", t.rowSchema()), nil + return &openapi3.Schema{ + Type: "object", + Properties: map[string]*openapi3.SchemaRef{ + "instances": t.rowSchema().NewRef(), + }, + Required: []string{"instances"}, + AdditionalPropertiesAllowed: func(b bool) *bool { return &b }(false), + }, nil } // https://www.tensorflow.org/tfx/serving/api_rest#specifying_input_tensors_in_column_format - return openapi3.NewObjectSchema().WithProperty("inputs", t.colSchema()), nil + return &openapi3.Schema{ + Type: "object", + Properties: map[string]*openapi3.SchemaRef{ + "inputs": t.colSchema().NewRef(), + }, + Required: []string{"inputs"}, + AdditionalPropertiesAllowed: func(b bool) *bool { return &b }(false), + }, nil } func canHaveRowSchema(t []TFTensor) bool { @@ -118,6 +132,7 @@ func (t *TFSignatureDef) rowSchema() *openapi3.Schema { schema.Items.Value.Properties[i.Name] = i.RowSchema().NewRef() schema.Items.Value.Required = append(schema.Items.Value.Required, i.Name) } + schema.Items.Value.AdditionalPropertiesAllowed = func(b bool) *bool { return &b }(false) return schema } @@ -132,5 +147,6 @@ func (t *TFSignatureDef) colSchema() *openapi3.Schema { schema.Properties[i.Name] = i.ColSchema().NewRef() schema.Required = append(schema.Required, i.Name) } + schema.AdditionalPropertiesAllowed = func(b bool) *bool { return &b }(false) return schema } diff --git a/tools/tf2openapi/types/tfsignaturedef_test.go b/tools/tf2openapi/types/tfsignaturedef_test.go index 1031370d91a..84d2ae24293 100644 --- a/tools/tf2openapi/types/tfsignaturedef_test.go +++ b/tools/tf2openapi/types/tfsignaturedef_test.go @@ -2,11 +2,12 @@ package types import ( "fmt" + "testing" "github.com/getkin/kin-openapi/openapi3" + "github.com/onsi/gomega" + "github.com/kubeflow/kfserving/pkg/utils" "github.com/kubeflow/kfserving/tools/tf2openapi/generated/framework" pb "github.com/kubeflow/kfserving/tools/tf2openapi/generated/protobuf" - "github.com/onsi/gomega" - "testing" ) /* Expected values */ @@ -141,7 +142,7 @@ func TestTFSignatureDefRowSchemaMultipleTensors(t *testing.T) { "signal": { Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(5), + MaxItems: utils.UInt64(5), MinItems: 5, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ @@ -153,12 +154,12 @@ func TestTFSignatureDefRowSchemaMultipleTensors(t *testing.T) { "sensor": { Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(2), + MaxItems: utils.UInt64(2), MinItems: 2, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(2), + MaxItems: utils.UInt64(2), MinItems: 2, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ @@ -170,12 +171,15 @@ func TestTFSignatureDefRowSchemaMultipleTensors(t *testing.T) { }, }, }, - Required: []string{"signal", "sensor"}, + Required: []string{"signal", "sensor"}, + AdditionalPropertiesAllowed: utils.Bool(false), }, }, }, }, }, + Required: []string{"instances"}, + AdditionalPropertiesAllowed: utils.Bool(false), } schema, err := tfSigDef.Schema() @@ -195,7 +199,7 @@ func TestTFSignatureDefRowSchemaSingleTensor(t *testing.T) { Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(3), + MaxItems: utils.UInt64(3), MinItems: 3, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ @@ -207,6 +211,8 @@ func TestTFSignatureDefRowSchemaSingleTensor(t *testing.T) { }, }, }, + Required: []string{"instances"}, + AdditionalPropertiesAllowed: utils.Bool(false), } schema, err := tfSigDef.Schema() g.Expect(schema).Should(gomega.Equal(expectedSchema)) @@ -258,12 +264,12 @@ func TestTFSignatureDefColSchemaMultipleTensors(t *testing.T) { "signal": { Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(2), + MaxItems: utils.UInt64(2), MinItems: 2, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(5), + MaxItems: utils.UInt64(5), MinItems: 5, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ @@ -277,17 +283,17 @@ func TestTFSignatureDefColSchemaMultipleTensors(t *testing.T) { "sensor": { Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(2), + MaxItems: utils.UInt64(2), MinItems: 2, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(2), + MaxItems: utils.UInt64(2), MinItems: 2, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(2), + MaxItems: utils.UInt64(2), MinItems: 2, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ @@ -301,10 +307,13 @@ func TestTFSignatureDefColSchemaMultipleTensors(t *testing.T) { }, }, }, - Required: []string{"signal", "sensor"}, + Required: []string{"signal", "sensor"}, + AdditionalPropertiesAllowed: utils.Bool(false), }, }, }, + Required: []string{"inputs"}, + AdditionalPropertiesAllowed: utils.Bool(false), } schema, err := tfSigDef.Schema() g.Expect(schema).Should(gomega.Equal(expectedSchema)) @@ -338,12 +347,12 @@ func TestTFSignatureDefColSchemaSingleTensor(t *testing.T) { "inputs": { Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(2), + MaxItems: utils.UInt64(2), MinItems: 2, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ Type: "array", - MaxItems: func(u uint64) *uint64 { return &u }(5), + MaxItems: utils.UInt64(5), MinItems: 5, Items: &openapi3.SchemaRef{ Value: &openapi3.Schema{ @@ -355,6 +364,8 @@ func TestTFSignatureDefColSchemaSingleTensor(t *testing.T) { }, }, }, + Required: []string{"inputs"}, + AdditionalPropertiesAllowed: utils.Bool(false), } schema, err := tfSigDef.Schema() g.Expect(schema).Should(gomega.Equal(expectedSchema)) @@ -388,6 +399,8 @@ func TestTFSignatureDefSchemaUnknownRank(t *testing.T) { Value: &openapi3.Schema{}, }, }, + Required: []string{"inputs"}, + AdditionalPropertiesAllowed: utils.Bool(false), } schema, err := tfSigDef.Schema() g.Expect(schema).Should(gomega.Equal(expectedSchema)) @@ -424,6 +437,8 @@ func TestTFSignatureDefSchemaScalar(t *testing.T) { }, }, }, + Required: []string{"inputs"}, + AdditionalPropertiesAllowed: utils.Bool(false), } schema, err := tfSigDef.Schema() g.Expect(schema).Should(gomega.Equal(expectedSchema)) @@ -475,10 +490,13 @@ func TestTFSignatureDefSchemaMultipleScalar(t *testing.T) { }, }, }, - Required: []string{"signal", "sensor"}, + Required: []string{"signal", "sensor"}, + AdditionalPropertiesAllowed: utils.Bool(false), }, }, }, + Required: []string{"inputs"}, + AdditionalPropertiesAllowed: utils.Bool(false), } schema, err := tfSigDef.Schema() g.Expect(schema).Should(gomega.Equal(expectedSchema))