From d8a7feef51d3344fa7e258aba1d9fbdab56dadcf Mon Sep 17 00:00:00 2001 From: Cody Oss <6331106+codyoss@users.noreply.github.com> Date: Wed, 20 Jan 2021 10:39:21 -0700 Subject: [PATCH] feat(datalabeling): start generating apiv1beta1 (#3582) --- .../apiv1beta1/data_labeling_client.go | 2208 +++++++++++++++++ .../data_labeling_client_example_test.go | 780 ++++++ datalabeling/apiv1beta1/doc.go | 116 + internal/.repo-metadata-full.json | 8 + internal/gapicgen/generator/config.go | 8 + 5 files changed, 3120 insertions(+) create mode 100644 datalabeling/apiv1beta1/data_labeling_client.go create mode 100644 datalabeling/apiv1beta1/data_labeling_client_example_test.go create mode 100644 datalabeling/apiv1beta1/doc.go diff --git a/datalabeling/apiv1beta1/data_labeling_client.go b/datalabeling/apiv1beta1/data_labeling_client.go new file mode 100644 index 00000000000..377489bb63e --- /dev/null +++ b/datalabeling/apiv1beta1/data_labeling_client.go @@ -0,0 +1,2208 @@ +// Copyright 2021 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by protoc-gen-go_gapic. DO NOT EDIT. + +package datalabeling + +import ( + "context" + "fmt" + "math" + "net/url" + "time" + + "cloud.google.com/go/longrunning" + lroauto "cloud.google.com/go/longrunning/autogen" + "github.com/golang/protobuf/proto" + gax "github.com/googleapis/gax-go/v2" + "google.golang.org/api/iterator" + "google.golang.org/api/option" + "google.golang.org/api/option/internaloption" + gtransport "google.golang.org/api/transport/grpc" + datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + longrunningpb "google.golang.org/genproto/googleapis/longrunning" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/metadata" +) + +var newClientHook clientHook + +// CallOptions contains the retry settings for each method of Client. +type CallOptions struct { + CreateDataset []gax.CallOption + GetDataset []gax.CallOption + ListDatasets []gax.CallOption + DeleteDataset []gax.CallOption + ImportData []gax.CallOption + ExportData []gax.CallOption + GetDataItem []gax.CallOption + ListDataItems []gax.CallOption + GetAnnotatedDataset []gax.CallOption + ListAnnotatedDatasets []gax.CallOption + DeleteAnnotatedDataset []gax.CallOption + LabelImage []gax.CallOption + LabelVideo []gax.CallOption + LabelText []gax.CallOption + GetExample []gax.CallOption + ListExamples []gax.CallOption + CreateAnnotationSpecSet []gax.CallOption + GetAnnotationSpecSet []gax.CallOption + ListAnnotationSpecSets []gax.CallOption + DeleteAnnotationSpecSet []gax.CallOption + CreateInstruction []gax.CallOption + GetInstruction []gax.CallOption + ListInstructions []gax.CallOption + DeleteInstruction []gax.CallOption + GetEvaluation []gax.CallOption + SearchEvaluations []gax.CallOption + SearchExampleComparisons []gax.CallOption + CreateEvaluationJob []gax.CallOption + UpdateEvaluationJob []gax.CallOption + GetEvaluationJob []gax.CallOption + PauseEvaluationJob []gax.CallOption + ResumeEvaluationJob []gax.CallOption + DeleteEvaluationJob []gax.CallOption + ListEvaluationJobs []gax.CallOption +} + +func defaultClientOptions() []option.ClientOption { + return []option.ClientOption{ + internaloption.WithDefaultEndpoint("datalabeling.googleapis.com:443"), + internaloption.WithDefaultMTLSEndpoint("datalabeling.mtls.googleapis.com:443"), + internaloption.WithDefaultAudience("https://datalabeling.googleapis.com/"), + internaloption.WithDefaultScopes(DefaultAuthScopes()...), + option.WithGRPCDialOption(grpc.WithDisableServiceConfig()), + option.WithGRPCDialOption(grpc.WithDefaultCallOptions( + grpc.MaxCallRecvMsgSize(math.MaxInt32))), + } +} + +func defaultCallOptions() *CallOptions { + return &CallOptions{ + CreateDataset: []gax.CallOption{}, + GetDataset: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ListDatasets: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + DeleteDataset: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ImportData: []gax.CallOption{}, + ExportData: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + GetDataItem: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ListDataItems: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + GetAnnotatedDataset: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ListAnnotatedDatasets: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + DeleteAnnotatedDataset: []gax.CallOption{}, + LabelImage: []gax.CallOption{}, + LabelVideo: []gax.CallOption{}, + LabelText: []gax.CallOption{}, + GetExample: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ListExamples: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + CreateAnnotationSpecSet: []gax.CallOption{}, + GetAnnotationSpecSet: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ListAnnotationSpecSets: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + DeleteAnnotationSpecSet: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + CreateInstruction: []gax.CallOption{}, + GetInstruction: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ListInstructions: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + DeleteInstruction: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + GetEvaluation: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + SearchEvaluations: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + SearchExampleComparisons: []gax.CallOption{}, + CreateEvaluationJob: []gax.CallOption{}, + UpdateEvaluationJob: []gax.CallOption{}, + GetEvaluationJob: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + PauseEvaluationJob: []gax.CallOption{}, + ResumeEvaluationJob: []gax.CallOption{}, + DeleteEvaluationJob: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + ListEvaluationJobs: []gax.CallOption{ + gax.WithRetry(func() gax.Retryer { + return gax.OnCodes([]codes.Code{ + codes.DeadlineExceeded, + codes.Unavailable, + }, gax.Backoff{ + Initial: 100 * time.Millisecond, + Max: 30000 * time.Millisecond, + Multiplier: 1.30, + }) + }), + }, + } +} + +// Client is a client for interacting with Data Labeling API. +// +// Methods, except Close, may be called concurrently. However, fields must not be modified concurrently with method calls. +type Client struct { + // Connection pool of gRPC connections to the service. + connPool gtransport.ConnPool + + // flag to opt out of default deadlines via GOOGLE_API_GO_EXPERIMENTAL_DISABLE_DEFAULT_DEADLINE + disableDeadlines bool + + // The gRPC API client. + client datalabelingpb.DataLabelingServiceClient + + // LROClient is used internally to handle longrunning operations. + // It is exposed so that its CallOptions can be modified if required. + // Users should not Close this client. + LROClient *lroauto.OperationsClient + + // The call options for this service. + CallOptions *CallOptions + + // The x-goog-* metadata to be sent with each request. + xGoogMetadata metadata.MD +} + +// NewClient creates a new data labeling service client. +// +// Service for the AI Platform Data Labeling API. +func NewClient(ctx context.Context, opts ...option.ClientOption) (*Client, error) { + clientOpts := defaultClientOptions() + + if newClientHook != nil { + hookOpts, err := newClientHook(ctx, clientHookParams{}) + if err != nil { + return nil, err + } + clientOpts = append(clientOpts, hookOpts...) + } + + disableDeadlines, err := checkDisableDeadlines() + if err != nil { + return nil, err + } + + connPool, err := gtransport.DialPool(ctx, append(clientOpts, opts...)...) + if err != nil { + return nil, err + } + c := &Client{ + connPool: connPool, + disableDeadlines: disableDeadlines, + CallOptions: defaultCallOptions(), + + client: datalabelingpb.NewDataLabelingServiceClient(connPool), + } + c.setGoogleClientInfo() + + c.LROClient, err = lroauto.NewOperationsClient(ctx, gtransport.WithConnPool(connPool)) + if err != nil { + // This error "should not happen", since we are just reusing old connection pool + // and never actually need to dial. + // If this does happen, we could leak connp. However, we cannot close conn: + // If the user invoked the constructor with option.WithGRPCConn, + // we would close a connection that's still in use. + // TODO: investigate error conditions. + return nil, err + } + return c, nil +} + +// Connection returns a connection to the API service. +// +// Deprecated. +func (c *Client) Connection() *grpc.ClientConn { + return c.connPool.Conn() +} + +// Close closes the connection to the API service. The user should invoke this when +// the client is no longer required. +func (c *Client) Close() error { + return c.connPool.Close() +} + +// setGoogleClientInfo sets the name and version of the application in +// the `x-goog-api-client` header passed on each request. Intended for +// use by Google-written clients. +func (c *Client) setGoogleClientInfo(keyval ...string) { + kv := append([]string{"gl-go", versionGo()}, keyval...) + kv = append(kv, "gapic", versionClient, "gax", gax.Version, "grpc", grpc.Version) + c.xGoogMetadata = metadata.Pairs("x-goog-api-client", gax.XGoogHeader(kv...)) +} + +// CreateDataset creates dataset. If success return a Dataset resource. +func (c *Client) CreateDataset(ctx context.Context, req *datalabelingpb.CreateDatasetRequest, opts ...gax.CallOption) (*datalabelingpb.Dataset, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.CreateDataset[0:len(c.CallOptions.CreateDataset):len(c.CallOptions.CreateDataset)], opts...) + var resp *datalabelingpb.Dataset + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.CreateDataset(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// GetDataset gets dataset by resource name. +func (c *Client) GetDataset(ctx context.Context, req *datalabelingpb.GetDatasetRequest, opts ...gax.CallOption) (*datalabelingpb.Dataset, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.GetDataset[0:len(c.CallOptions.GetDataset):len(c.CallOptions.GetDataset)], opts...) + var resp *datalabelingpb.Dataset + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.GetDataset(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// ListDatasets lists datasets under a project. Pagination is supported. +func (c *Client) ListDatasets(ctx context.Context, req *datalabelingpb.ListDatasetsRequest, opts ...gax.CallOption) *DatasetIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ListDatasets[0:len(c.CallOptions.ListDatasets):len(c.CallOptions.ListDatasets)], opts...) + it := &DatasetIterator{} + req = proto.Clone(req).(*datalabelingpb.ListDatasetsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.Dataset, string, error) { + var resp *datalabelingpb.ListDatasetsResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ListDatasets(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetDatasets(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// DeleteDataset deletes a dataset by resource name. +func (c *Client) DeleteDataset(ctx context.Context, req *datalabelingpb.DeleteDatasetRequest, opts ...gax.CallOption) error { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.DeleteDataset[0:len(c.CallOptions.DeleteDataset):len(c.CallOptions.DeleteDataset)], opts...) + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + _, err = c.client.DeleteDataset(ctx, req, settings.GRPC...) + return err + }, opts...) + return err +} + +// ImportData imports data into dataset based on source locations defined in request. +// It can be called multiple times for the same dataset. Each dataset can +// only have one long running operation running on it. For example, no +// labeling task (also long running operation) can be started while +// importing is still ongoing. Vice versa. +func (c *Client) ImportData(ctx context.Context, req *datalabelingpb.ImportDataRequest, opts ...gax.CallOption) (*ImportDataOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ImportData[0:len(c.CallOptions.ImportData):len(c.CallOptions.ImportData)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ImportData(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &ImportDataOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, resp), + }, nil +} + +// ExportData exports data and annotations from dataset. +func (c *Client) ExportData(ctx context.Context, req *datalabelingpb.ExportDataRequest, opts ...gax.CallOption) (*ExportDataOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ExportData[0:len(c.CallOptions.ExportData):len(c.CallOptions.ExportData)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ExportData(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &ExportDataOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, resp), + }, nil +} + +// GetDataItem gets a data item in a dataset by resource name. This API can be +// called after data are imported into dataset. +func (c *Client) GetDataItem(ctx context.Context, req *datalabelingpb.GetDataItemRequest, opts ...gax.CallOption) (*datalabelingpb.DataItem, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.GetDataItem[0:len(c.CallOptions.GetDataItem):len(c.CallOptions.GetDataItem)], opts...) + var resp *datalabelingpb.DataItem + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.GetDataItem(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// ListDataItems lists data items in a dataset. This API can be called after data +// are imported into dataset. Pagination is supported. +func (c *Client) ListDataItems(ctx context.Context, req *datalabelingpb.ListDataItemsRequest, opts ...gax.CallOption) *DataItemIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ListDataItems[0:len(c.CallOptions.ListDataItems):len(c.CallOptions.ListDataItems)], opts...) + it := &DataItemIterator{} + req = proto.Clone(req).(*datalabelingpb.ListDataItemsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.DataItem, string, error) { + var resp *datalabelingpb.ListDataItemsResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ListDataItems(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetDataItems(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// GetAnnotatedDataset gets an annotated dataset by resource name. +func (c *Client) GetAnnotatedDataset(ctx context.Context, req *datalabelingpb.GetAnnotatedDatasetRequest, opts ...gax.CallOption) (*datalabelingpb.AnnotatedDataset, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.GetAnnotatedDataset[0:len(c.CallOptions.GetAnnotatedDataset):len(c.CallOptions.GetAnnotatedDataset)], opts...) + var resp *datalabelingpb.AnnotatedDataset + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.GetAnnotatedDataset(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// ListAnnotatedDatasets lists annotated datasets for a dataset. Pagination is supported. +func (c *Client) ListAnnotatedDatasets(ctx context.Context, req *datalabelingpb.ListAnnotatedDatasetsRequest, opts ...gax.CallOption) *AnnotatedDatasetIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ListAnnotatedDatasets[0:len(c.CallOptions.ListAnnotatedDatasets):len(c.CallOptions.ListAnnotatedDatasets)], opts...) + it := &AnnotatedDatasetIterator{} + req = proto.Clone(req).(*datalabelingpb.ListAnnotatedDatasetsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.AnnotatedDataset, string, error) { + var resp *datalabelingpb.ListAnnotatedDatasetsResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ListAnnotatedDatasets(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetAnnotatedDatasets(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// DeleteAnnotatedDataset deletes an annotated dataset by resource name. +func (c *Client) DeleteAnnotatedDataset(ctx context.Context, req *datalabelingpb.DeleteAnnotatedDatasetRequest, opts ...gax.CallOption) error { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.DeleteAnnotatedDataset[0:len(c.CallOptions.DeleteAnnotatedDataset):len(c.CallOptions.DeleteAnnotatedDataset)], opts...) + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + _, err = c.client.DeleteAnnotatedDataset(ctx, req, settings.GRPC...) + return err + }, opts...) + return err +} + +// LabelImage starts a labeling task for image. The type of image labeling task is +// configured by feature in the request. +func (c *Client) LabelImage(ctx context.Context, req *datalabelingpb.LabelImageRequest, opts ...gax.CallOption) (*LabelImageOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.LabelImage[0:len(c.CallOptions.LabelImage):len(c.CallOptions.LabelImage)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.LabelImage(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &LabelImageOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, resp), + }, nil +} + +// LabelVideo starts a labeling task for video. The type of video labeling task is +// configured by feature in the request. +func (c *Client) LabelVideo(ctx context.Context, req *datalabelingpb.LabelVideoRequest, opts ...gax.CallOption) (*LabelVideoOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.LabelVideo[0:len(c.CallOptions.LabelVideo):len(c.CallOptions.LabelVideo)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.LabelVideo(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &LabelVideoOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, resp), + }, nil +} + +// LabelText starts a labeling task for text. The type of text labeling task is +// configured by feature in the request. +func (c *Client) LabelText(ctx context.Context, req *datalabelingpb.LabelTextRequest, opts ...gax.CallOption) (*LabelTextOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.LabelText[0:len(c.CallOptions.LabelText):len(c.CallOptions.LabelText)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.LabelText(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &LabelTextOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, resp), + }, nil +} + +// GetExample gets an example by resource name, including both data and annotation. +func (c *Client) GetExample(ctx context.Context, req *datalabelingpb.GetExampleRequest, opts ...gax.CallOption) (*datalabelingpb.Example, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.GetExample[0:len(c.CallOptions.GetExample):len(c.CallOptions.GetExample)], opts...) + var resp *datalabelingpb.Example + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.GetExample(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// ListExamples lists examples in an annotated dataset. Pagination is supported. +func (c *Client) ListExamples(ctx context.Context, req *datalabelingpb.ListExamplesRequest, opts ...gax.CallOption) *ExampleIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ListExamples[0:len(c.CallOptions.ListExamples):len(c.CallOptions.ListExamples)], opts...) + it := &ExampleIterator{} + req = proto.Clone(req).(*datalabelingpb.ListExamplesRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.Example, string, error) { + var resp *datalabelingpb.ListExamplesResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ListExamples(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetExamples(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// CreateAnnotationSpecSet creates an annotation spec set by providing a set of labels. +func (c *Client) CreateAnnotationSpecSet(ctx context.Context, req *datalabelingpb.CreateAnnotationSpecSetRequest, opts ...gax.CallOption) (*datalabelingpb.AnnotationSpecSet, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.CreateAnnotationSpecSet[0:len(c.CallOptions.CreateAnnotationSpecSet):len(c.CallOptions.CreateAnnotationSpecSet)], opts...) + var resp *datalabelingpb.AnnotationSpecSet + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.CreateAnnotationSpecSet(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// GetAnnotationSpecSet gets an annotation spec set by resource name. +func (c *Client) GetAnnotationSpecSet(ctx context.Context, req *datalabelingpb.GetAnnotationSpecSetRequest, opts ...gax.CallOption) (*datalabelingpb.AnnotationSpecSet, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.GetAnnotationSpecSet[0:len(c.CallOptions.GetAnnotationSpecSet):len(c.CallOptions.GetAnnotationSpecSet)], opts...) + var resp *datalabelingpb.AnnotationSpecSet + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.GetAnnotationSpecSet(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// ListAnnotationSpecSets lists annotation spec sets for a project. Pagination is supported. +func (c *Client) ListAnnotationSpecSets(ctx context.Context, req *datalabelingpb.ListAnnotationSpecSetsRequest, opts ...gax.CallOption) *AnnotationSpecSetIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ListAnnotationSpecSets[0:len(c.CallOptions.ListAnnotationSpecSets):len(c.CallOptions.ListAnnotationSpecSets)], opts...) + it := &AnnotationSpecSetIterator{} + req = proto.Clone(req).(*datalabelingpb.ListAnnotationSpecSetsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.AnnotationSpecSet, string, error) { + var resp *datalabelingpb.ListAnnotationSpecSetsResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ListAnnotationSpecSets(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetAnnotationSpecSets(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// DeleteAnnotationSpecSet deletes an annotation spec set by resource name. +func (c *Client) DeleteAnnotationSpecSet(ctx context.Context, req *datalabelingpb.DeleteAnnotationSpecSetRequest, opts ...gax.CallOption) error { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.DeleteAnnotationSpecSet[0:len(c.CallOptions.DeleteAnnotationSpecSet):len(c.CallOptions.DeleteAnnotationSpecSet)], opts...) + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + _, err = c.client.DeleteAnnotationSpecSet(ctx, req, settings.GRPC...) + return err + }, opts...) + return err +} + +// CreateInstruction creates an instruction for how data should be labeled. +func (c *Client) CreateInstruction(ctx context.Context, req *datalabelingpb.CreateInstructionRequest, opts ...gax.CallOption) (*CreateInstructionOperation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.CreateInstruction[0:len(c.CallOptions.CreateInstruction):len(c.CallOptions.CreateInstruction)], opts...) + var resp *longrunningpb.Operation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.CreateInstruction(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return &CreateInstructionOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, resp), + }, nil +} + +// GetInstruction gets an instruction by resource name. +func (c *Client) GetInstruction(ctx context.Context, req *datalabelingpb.GetInstructionRequest, opts ...gax.CallOption) (*datalabelingpb.Instruction, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.GetInstruction[0:len(c.CallOptions.GetInstruction):len(c.CallOptions.GetInstruction)], opts...) + var resp *datalabelingpb.Instruction + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.GetInstruction(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// ListInstructions lists instructions for a project. Pagination is supported. +func (c *Client) ListInstructions(ctx context.Context, req *datalabelingpb.ListInstructionsRequest, opts ...gax.CallOption) *InstructionIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ListInstructions[0:len(c.CallOptions.ListInstructions):len(c.CallOptions.ListInstructions)], opts...) + it := &InstructionIterator{} + req = proto.Clone(req).(*datalabelingpb.ListInstructionsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.Instruction, string, error) { + var resp *datalabelingpb.ListInstructionsResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ListInstructions(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetInstructions(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// DeleteInstruction deletes an instruction object by resource name. +func (c *Client) DeleteInstruction(ctx context.Context, req *datalabelingpb.DeleteInstructionRequest, opts ...gax.CallOption) error { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.DeleteInstruction[0:len(c.CallOptions.DeleteInstruction):len(c.CallOptions.DeleteInstruction)], opts...) + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + _, err = c.client.DeleteInstruction(ctx, req, settings.GRPC...) + return err + }, opts...) + return err +} + +// GetEvaluation gets an evaluation by resource name (to search, use +// projects.evaluations.search). +func (c *Client) GetEvaluation(ctx context.Context, req *datalabelingpb.GetEvaluationRequest, opts ...gax.CallOption) (*datalabelingpb.Evaluation, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.GetEvaluation[0:len(c.CallOptions.GetEvaluation):len(c.CallOptions.GetEvaluation)], opts...) + var resp *datalabelingpb.Evaluation + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.GetEvaluation(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// SearchEvaluations searches evaluations within a project. +func (c *Client) SearchEvaluations(ctx context.Context, req *datalabelingpb.SearchEvaluationsRequest, opts ...gax.CallOption) *EvaluationIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.SearchEvaluations[0:len(c.CallOptions.SearchEvaluations):len(c.CallOptions.SearchEvaluations)], opts...) + it := &EvaluationIterator{} + req = proto.Clone(req).(*datalabelingpb.SearchEvaluationsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.Evaluation, string, error) { + var resp *datalabelingpb.SearchEvaluationsResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.SearchEvaluations(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetEvaluations(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// SearchExampleComparisons searches example comparisons from an evaluation. The return format is a +// list of example comparisons that show ground truth and prediction(s) for +// a single input. Search by providing an evaluation ID. +func (c *Client) SearchExampleComparisons(ctx context.Context, req *datalabelingpb.SearchExampleComparisonsRequest, opts ...gax.CallOption) *SearchExampleComparisonsResponse_ExampleComparisonIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.SearchExampleComparisons[0:len(c.CallOptions.SearchExampleComparisons):len(c.CallOptions.SearchExampleComparisons)], opts...) + it := &SearchExampleComparisonsResponse_ExampleComparisonIterator{} + req = proto.Clone(req).(*datalabelingpb.SearchExampleComparisonsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.SearchExampleComparisonsResponse_ExampleComparison, string, error) { + var resp *datalabelingpb.SearchExampleComparisonsResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.SearchExampleComparisons(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetExampleComparisons(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// CreateEvaluationJob creates an evaluation job. +func (c *Client) CreateEvaluationJob(ctx context.Context, req *datalabelingpb.CreateEvaluationJobRequest, opts ...gax.CallOption) (*datalabelingpb.EvaluationJob, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.CreateEvaluationJob[0:len(c.CallOptions.CreateEvaluationJob):len(c.CallOptions.CreateEvaluationJob)], opts...) + var resp *datalabelingpb.EvaluationJob + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.CreateEvaluationJob(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// UpdateEvaluationJob updates an evaluation job. You can only update certain fields of the job’s +// EvaluationJobConfig: humanAnnotationConfig.instruction, +// exampleCount, and exampleSamplePercentage. +// +// If you want to change any other aspect of the evaluation job, you must +// delete the job and create a new one. +func (c *Client) UpdateEvaluationJob(ctx context.Context, req *datalabelingpb.UpdateEvaluationJobRequest, opts ...gax.CallOption) (*datalabelingpb.EvaluationJob, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "evaluation_job.name", url.QueryEscape(req.GetEvaluationJob().GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.UpdateEvaluationJob[0:len(c.CallOptions.UpdateEvaluationJob):len(c.CallOptions.UpdateEvaluationJob)], opts...) + var resp *datalabelingpb.EvaluationJob + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.UpdateEvaluationJob(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// GetEvaluationJob gets an evaluation job by resource name. +func (c *Client) GetEvaluationJob(ctx context.Context, req *datalabelingpb.GetEvaluationJobRequest, opts ...gax.CallOption) (*datalabelingpb.EvaluationJob, error) { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.GetEvaluationJob[0:len(c.CallOptions.GetEvaluationJob):len(c.CallOptions.GetEvaluationJob)], opts...) + var resp *datalabelingpb.EvaluationJob + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.GetEvaluationJob(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, err + } + return resp, nil +} + +// PauseEvaluationJob pauses an evaluation job. Pausing an evaluation job that is already in a +// PAUSED state is a no-op. +func (c *Client) PauseEvaluationJob(ctx context.Context, req *datalabelingpb.PauseEvaluationJobRequest, opts ...gax.CallOption) error { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.PauseEvaluationJob[0:len(c.CallOptions.PauseEvaluationJob):len(c.CallOptions.PauseEvaluationJob)], opts...) + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + _, err = c.client.PauseEvaluationJob(ctx, req, settings.GRPC...) + return err + }, opts...) + return err +} + +// ResumeEvaluationJob resumes a paused evaluation job. A deleted evaluation job can’t be resumed. +// Resuming a running or scheduled evaluation job is a no-op. +func (c *Client) ResumeEvaluationJob(ctx context.Context, req *datalabelingpb.ResumeEvaluationJobRequest, opts ...gax.CallOption) error { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ResumeEvaluationJob[0:len(c.CallOptions.ResumeEvaluationJob):len(c.CallOptions.ResumeEvaluationJob)], opts...) + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + _, err = c.client.ResumeEvaluationJob(ctx, req, settings.GRPC...) + return err + }, opts...) + return err +} + +// DeleteEvaluationJob stops and deletes an evaluation job. +func (c *Client) DeleteEvaluationJob(ctx context.Context, req *datalabelingpb.DeleteEvaluationJobRequest, opts ...gax.CallOption) error { + if _, ok := ctx.Deadline(); !ok && !c.disableDeadlines { + cctx, cancel := context.WithTimeout(ctx, 30000*time.Millisecond) + defer cancel() + ctx = cctx + } + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "name", url.QueryEscape(req.GetName()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.DeleteEvaluationJob[0:len(c.CallOptions.DeleteEvaluationJob):len(c.CallOptions.DeleteEvaluationJob)], opts...) + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + _, err = c.client.DeleteEvaluationJob(ctx, req, settings.GRPC...) + return err + }, opts...) + return err +} + +// ListEvaluationJobs lists all evaluation jobs within a project with possible filters. +// Pagination is supported. +func (c *Client) ListEvaluationJobs(ctx context.Context, req *datalabelingpb.ListEvaluationJobsRequest, opts ...gax.CallOption) *EvaluationJobIterator { + md := metadata.Pairs("x-goog-request-params", fmt.Sprintf("%s=%v", "parent", url.QueryEscape(req.GetParent()))) + ctx = insertMetadata(ctx, c.xGoogMetadata, md) + opts = append(c.CallOptions.ListEvaluationJobs[0:len(c.CallOptions.ListEvaluationJobs):len(c.CallOptions.ListEvaluationJobs)], opts...) + it := &EvaluationJobIterator{} + req = proto.Clone(req).(*datalabelingpb.ListEvaluationJobsRequest) + it.InternalFetch = func(pageSize int, pageToken string) ([]*datalabelingpb.EvaluationJob, string, error) { + var resp *datalabelingpb.ListEvaluationJobsResponse + req.PageToken = pageToken + if pageSize > math.MaxInt32 { + req.PageSize = math.MaxInt32 + } else { + req.PageSize = int32(pageSize) + } + err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error { + var err error + resp, err = c.client.ListEvaluationJobs(ctx, req, settings.GRPC...) + return err + }, opts...) + if err != nil { + return nil, "", err + } + + it.Response = resp + return resp.GetEvaluationJobs(), resp.GetNextPageToken(), nil + } + fetch := func(pageSize int, pageToken string) (string, error) { + items, nextPageToken, err := it.InternalFetch(pageSize, pageToken) + if err != nil { + return "", err + } + it.items = append(it.items, items...) + return nextPageToken, nil + } + it.pageInfo, it.nextFunc = iterator.NewPageInfo(fetch, it.bufLen, it.takeBuf) + it.pageInfo.MaxSize = int(req.GetPageSize()) + it.pageInfo.Token = req.GetPageToken() + return it +} + +// CreateInstructionOperation manages a long-running operation from CreateInstruction. +type CreateInstructionOperation struct { + lro *longrunning.Operation +} + +// CreateInstructionOperation returns a new CreateInstructionOperation from a given name. +// The name must be that of a previously created CreateInstructionOperation, possibly from a different process. +func (c *Client) CreateInstructionOperation(name string) *CreateInstructionOperation { + return &CreateInstructionOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *CreateInstructionOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.Instruction, error) { + var resp datalabelingpb.Instruction + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// Poll fetches the latest state of the long-running operation. +// +// Poll also fetches the latest metadata, which can be retrieved by Metadata. +// +// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and +// the operation has completed with failure, the error is returned and op.Done will return true. +// If Poll succeeds and the operation has completed successfully, +// op.Done will return true, and the response of the operation is returned. +// If Poll succeeds and the operation has not completed, the returned response and error are both nil. +func (op *CreateInstructionOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.Instruction, error) { + var resp datalabelingpb.Instruction + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// Metadata returns metadata associated with the long-running operation. +// Metadata itself does not contact the server, but Poll does. +// To get the latest metadata, call this method after a successful call to Poll. +// If the metadata is not available, the returned metadata and error are both nil. +func (op *CreateInstructionOperation) Metadata() (*datalabelingpb.CreateInstructionMetadata, error) { + var meta datalabelingpb.CreateInstructionMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *CreateInstructionOperation) Done() bool { + return op.lro.Done() +} + +// Name returns the name of the long-running operation. +// The name is assigned by the server and is unique within the service from which the operation is created. +func (op *CreateInstructionOperation) Name() string { + return op.lro.Name() +} + +// ExportDataOperation manages a long-running operation from ExportData. +type ExportDataOperation struct { + lro *longrunning.Operation +} + +// ExportDataOperation returns a new ExportDataOperation from a given name. +// The name must be that of a previously created ExportDataOperation, possibly from a different process. +func (c *Client) ExportDataOperation(name string) *ExportDataOperation { + return &ExportDataOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *ExportDataOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.ExportDataOperationResponse, error) { + var resp datalabelingpb.ExportDataOperationResponse + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// Poll fetches the latest state of the long-running operation. +// +// Poll also fetches the latest metadata, which can be retrieved by Metadata. +// +// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and +// the operation has completed with failure, the error is returned and op.Done will return true. +// If Poll succeeds and the operation has completed successfully, +// op.Done will return true, and the response of the operation is returned. +// If Poll succeeds and the operation has not completed, the returned response and error are both nil. +func (op *ExportDataOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.ExportDataOperationResponse, error) { + var resp datalabelingpb.ExportDataOperationResponse + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// Metadata returns metadata associated with the long-running operation. +// Metadata itself does not contact the server, but Poll does. +// To get the latest metadata, call this method after a successful call to Poll. +// If the metadata is not available, the returned metadata and error are both nil. +func (op *ExportDataOperation) Metadata() (*datalabelingpb.ExportDataOperationMetadata, error) { + var meta datalabelingpb.ExportDataOperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *ExportDataOperation) Done() bool { + return op.lro.Done() +} + +// Name returns the name of the long-running operation. +// The name is assigned by the server and is unique within the service from which the operation is created. +func (op *ExportDataOperation) Name() string { + return op.lro.Name() +} + +// ImportDataOperation manages a long-running operation from ImportData. +type ImportDataOperation struct { + lro *longrunning.Operation +} + +// ImportDataOperation returns a new ImportDataOperation from a given name. +// The name must be that of a previously created ImportDataOperation, possibly from a different process. +func (c *Client) ImportDataOperation(name string) *ImportDataOperation { + return &ImportDataOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *ImportDataOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.ImportDataOperationResponse, error) { + var resp datalabelingpb.ImportDataOperationResponse + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// Poll fetches the latest state of the long-running operation. +// +// Poll also fetches the latest metadata, which can be retrieved by Metadata. +// +// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and +// the operation has completed with failure, the error is returned and op.Done will return true. +// If Poll succeeds and the operation has completed successfully, +// op.Done will return true, and the response of the operation is returned. +// If Poll succeeds and the operation has not completed, the returned response and error are both nil. +func (op *ImportDataOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.ImportDataOperationResponse, error) { + var resp datalabelingpb.ImportDataOperationResponse + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// Metadata returns metadata associated with the long-running operation. +// Metadata itself does not contact the server, but Poll does. +// To get the latest metadata, call this method after a successful call to Poll. +// If the metadata is not available, the returned metadata and error are both nil. +func (op *ImportDataOperation) Metadata() (*datalabelingpb.ImportDataOperationMetadata, error) { + var meta datalabelingpb.ImportDataOperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *ImportDataOperation) Done() bool { + return op.lro.Done() +} + +// Name returns the name of the long-running operation. +// The name is assigned by the server and is unique within the service from which the operation is created. +func (op *ImportDataOperation) Name() string { + return op.lro.Name() +} + +// LabelImageOperation manages a long-running operation from LabelImage. +type LabelImageOperation struct { + lro *longrunning.Operation +} + +// LabelImageOperation returns a new LabelImageOperation from a given name. +// The name must be that of a previously created LabelImageOperation, possibly from a different process. +func (c *Client) LabelImageOperation(name string) *LabelImageOperation { + return &LabelImageOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *LabelImageOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.AnnotatedDataset, error) { + var resp datalabelingpb.AnnotatedDataset + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// Poll fetches the latest state of the long-running operation. +// +// Poll also fetches the latest metadata, which can be retrieved by Metadata. +// +// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and +// the operation has completed with failure, the error is returned and op.Done will return true. +// If Poll succeeds and the operation has completed successfully, +// op.Done will return true, and the response of the operation is returned. +// If Poll succeeds and the operation has not completed, the returned response and error are both nil. +func (op *LabelImageOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.AnnotatedDataset, error) { + var resp datalabelingpb.AnnotatedDataset + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// Metadata returns metadata associated with the long-running operation. +// Metadata itself does not contact the server, but Poll does. +// To get the latest metadata, call this method after a successful call to Poll. +// If the metadata is not available, the returned metadata and error are both nil. +func (op *LabelImageOperation) Metadata() (*datalabelingpb.LabelOperationMetadata, error) { + var meta datalabelingpb.LabelOperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *LabelImageOperation) Done() bool { + return op.lro.Done() +} + +// Name returns the name of the long-running operation. +// The name is assigned by the server and is unique within the service from which the operation is created. +func (op *LabelImageOperation) Name() string { + return op.lro.Name() +} + +// LabelTextOperation manages a long-running operation from LabelText. +type LabelTextOperation struct { + lro *longrunning.Operation +} + +// LabelTextOperation returns a new LabelTextOperation from a given name. +// The name must be that of a previously created LabelTextOperation, possibly from a different process. +func (c *Client) LabelTextOperation(name string) *LabelTextOperation { + return &LabelTextOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *LabelTextOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.AnnotatedDataset, error) { + var resp datalabelingpb.AnnotatedDataset + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// Poll fetches the latest state of the long-running operation. +// +// Poll also fetches the latest metadata, which can be retrieved by Metadata. +// +// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and +// the operation has completed with failure, the error is returned and op.Done will return true. +// If Poll succeeds and the operation has completed successfully, +// op.Done will return true, and the response of the operation is returned. +// If Poll succeeds and the operation has not completed, the returned response and error are both nil. +func (op *LabelTextOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.AnnotatedDataset, error) { + var resp datalabelingpb.AnnotatedDataset + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// Metadata returns metadata associated with the long-running operation. +// Metadata itself does not contact the server, but Poll does. +// To get the latest metadata, call this method after a successful call to Poll. +// If the metadata is not available, the returned metadata and error are both nil. +func (op *LabelTextOperation) Metadata() (*datalabelingpb.LabelOperationMetadata, error) { + var meta datalabelingpb.LabelOperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *LabelTextOperation) Done() bool { + return op.lro.Done() +} + +// Name returns the name of the long-running operation. +// The name is assigned by the server and is unique within the service from which the operation is created. +func (op *LabelTextOperation) Name() string { + return op.lro.Name() +} + +// LabelVideoOperation manages a long-running operation from LabelVideo. +type LabelVideoOperation struct { + lro *longrunning.Operation +} + +// LabelVideoOperation returns a new LabelVideoOperation from a given name. +// The name must be that of a previously created LabelVideoOperation, possibly from a different process. +func (c *Client) LabelVideoOperation(name string) *LabelVideoOperation { + return &LabelVideoOperation{ + lro: longrunning.InternalNewOperation(c.LROClient, &longrunningpb.Operation{Name: name}), + } +} + +// Wait blocks until the long-running operation is completed, returning the response and any errors encountered. +// +// See documentation of Poll for error-handling information. +func (op *LabelVideoOperation) Wait(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.AnnotatedDataset, error) { + var resp datalabelingpb.AnnotatedDataset + if err := op.lro.WaitWithInterval(ctx, &resp, time.Minute, opts...); err != nil { + return nil, err + } + return &resp, nil +} + +// Poll fetches the latest state of the long-running operation. +// +// Poll also fetches the latest metadata, which can be retrieved by Metadata. +// +// If Poll fails, the error is returned and op is unmodified. If Poll succeeds and +// the operation has completed with failure, the error is returned and op.Done will return true. +// If Poll succeeds and the operation has completed successfully, +// op.Done will return true, and the response of the operation is returned. +// If Poll succeeds and the operation has not completed, the returned response and error are both nil. +func (op *LabelVideoOperation) Poll(ctx context.Context, opts ...gax.CallOption) (*datalabelingpb.AnnotatedDataset, error) { + var resp datalabelingpb.AnnotatedDataset + if err := op.lro.Poll(ctx, &resp, opts...); err != nil { + return nil, err + } + if !op.Done() { + return nil, nil + } + return &resp, nil +} + +// Metadata returns metadata associated with the long-running operation. +// Metadata itself does not contact the server, but Poll does. +// To get the latest metadata, call this method after a successful call to Poll. +// If the metadata is not available, the returned metadata and error are both nil. +func (op *LabelVideoOperation) Metadata() (*datalabelingpb.LabelOperationMetadata, error) { + var meta datalabelingpb.LabelOperationMetadata + if err := op.lro.Metadata(&meta); err == longrunning.ErrNoMetadata { + return nil, nil + } else if err != nil { + return nil, err + } + return &meta, nil +} + +// Done reports whether the long-running operation has completed. +func (op *LabelVideoOperation) Done() bool { + return op.lro.Done() +} + +// Name returns the name of the long-running operation. +// The name is assigned by the server and is unique within the service from which the operation is created. +func (op *LabelVideoOperation) Name() string { + return op.lro.Name() +} + +// AnnotatedDatasetIterator manages a stream of *datalabelingpb.AnnotatedDataset. +type AnnotatedDatasetIterator struct { + items []*datalabelingpb.AnnotatedDataset + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.AnnotatedDataset, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *AnnotatedDatasetIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *AnnotatedDatasetIterator) Next() (*datalabelingpb.AnnotatedDataset, error) { + var item *datalabelingpb.AnnotatedDataset + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *AnnotatedDatasetIterator) bufLen() int { + return len(it.items) +} + +func (it *AnnotatedDatasetIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// AnnotationSpecSetIterator manages a stream of *datalabelingpb.AnnotationSpecSet. +type AnnotationSpecSetIterator struct { + items []*datalabelingpb.AnnotationSpecSet + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.AnnotationSpecSet, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *AnnotationSpecSetIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *AnnotationSpecSetIterator) Next() (*datalabelingpb.AnnotationSpecSet, error) { + var item *datalabelingpb.AnnotationSpecSet + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *AnnotationSpecSetIterator) bufLen() int { + return len(it.items) +} + +func (it *AnnotationSpecSetIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// DataItemIterator manages a stream of *datalabelingpb.DataItem. +type DataItemIterator struct { + items []*datalabelingpb.DataItem + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.DataItem, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *DataItemIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *DataItemIterator) Next() (*datalabelingpb.DataItem, error) { + var item *datalabelingpb.DataItem + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *DataItemIterator) bufLen() int { + return len(it.items) +} + +func (it *DataItemIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// DatasetIterator manages a stream of *datalabelingpb.Dataset. +type DatasetIterator struct { + items []*datalabelingpb.Dataset + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.Dataset, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *DatasetIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *DatasetIterator) Next() (*datalabelingpb.Dataset, error) { + var item *datalabelingpb.Dataset + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *DatasetIterator) bufLen() int { + return len(it.items) +} + +func (it *DatasetIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// EvaluationIterator manages a stream of *datalabelingpb.Evaluation. +type EvaluationIterator struct { + items []*datalabelingpb.Evaluation + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.Evaluation, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *EvaluationIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *EvaluationIterator) Next() (*datalabelingpb.Evaluation, error) { + var item *datalabelingpb.Evaluation + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *EvaluationIterator) bufLen() int { + return len(it.items) +} + +func (it *EvaluationIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// EvaluationJobIterator manages a stream of *datalabelingpb.EvaluationJob. +type EvaluationJobIterator struct { + items []*datalabelingpb.EvaluationJob + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.EvaluationJob, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *EvaluationJobIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *EvaluationJobIterator) Next() (*datalabelingpb.EvaluationJob, error) { + var item *datalabelingpb.EvaluationJob + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *EvaluationJobIterator) bufLen() int { + return len(it.items) +} + +func (it *EvaluationJobIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// ExampleIterator manages a stream of *datalabelingpb.Example. +type ExampleIterator struct { + items []*datalabelingpb.Example + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.Example, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *ExampleIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *ExampleIterator) Next() (*datalabelingpb.Example, error) { + var item *datalabelingpb.Example + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *ExampleIterator) bufLen() int { + return len(it.items) +} + +func (it *ExampleIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// InstructionIterator manages a stream of *datalabelingpb.Instruction. +type InstructionIterator struct { + items []*datalabelingpb.Instruction + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.Instruction, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *InstructionIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *InstructionIterator) Next() (*datalabelingpb.Instruction, error) { + var item *datalabelingpb.Instruction + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *InstructionIterator) bufLen() int { + return len(it.items) +} + +func (it *InstructionIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} + +// SearchExampleComparisonsResponse_ExampleComparisonIterator manages a stream of *datalabelingpb.SearchExampleComparisonsResponse_ExampleComparison. +type SearchExampleComparisonsResponse_ExampleComparisonIterator struct { + items []*datalabelingpb.SearchExampleComparisonsResponse_ExampleComparison + pageInfo *iterator.PageInfo + nextFunc func() error + + // Response is the raw response for the current page. + // It must be cast to the RPC response type. + // Calling Next() or InternalFetch() updates this value. + Response interface{} + + // InternalFetch is for use by the Google Cloud Libraries only. + // It is not part of the stable interface of this package. + // + // InternalFetch returns results from a single call to the underlying RPC. + // The number of results is no greater than pageSize. + // If there are no more results, nextPageToken is empty and err is nil. + InternalFetch func(pageSize int, pageToken string) (results []*datalabelingpb.SearchExampleComparisonsResponse_ExampleComparison, nextPageToken string, err error) +} + +// PageInfo supports pagination. See the google.golang.org/api/iterator package for details. +func (it *SearchExampleComparisonsResponse_ExampleComparisonIterator) PageInfo() *iterator.PageInfo { + return it.pageInfo +} + +// Next returns the next result. Its second return value is iterator.Done if there are no more +// results. Once Next returns Done, all subsequent calls will return Done. +func (it *SearchExampleComparisonsResponse_ExampleComparisonIterator) Next() (*datalabelingpb.SearchExampleComparisonsResponse_ExampleComparison, error) { + var item *datalabelingpb.SearchExampleComparisonsResponse_ExampleComparison + if err := it.nextFunc(); err != nil { + return item, err + } + item = it.items[0] + it.items = it.items[1:] + return item, nil +} + +func (it *SearchExampleComparisonsResponse_ExampleComparisonIterator) bufLen() int { + return len(it.items) +} + +func (it *SearchExampleComparisonsResponse_ExampleComparisonIterator) takeBuf() interface{} { + b := it.items + it.items = nil + return b +} diff --git a/datalabeling/apiv1beta1/data_labeling_client_example_test.go b/datalabeling/apiv1beta1/data_labeling_client_example_test.go new file mode 100644 index 00000000000..d751242ff7e --- /dev/null +++ b/datalabeling/apiv1beta1/data_labeling_client_example_test.go @@ -0,0 +1,780 @@ +// Copyright 2021 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by protoc-gen-go_gapic. DO NOT EDIT. + +package datalabeling_test + +import ( + "context" + + datalabeling "cloud.google.com/go/datalabeling/apiv1beta1" + "google.golang.org/api/iterator" + datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" +) + +func ExampleNewClient() { + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use client. + _ = c +} + +func ExampleClient_CreateDataset() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.CreateDatasetRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.CreateDataset(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_GetDataset() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.GetDatasetRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.GetDataset(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_ListDatasets() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ListDatasetsRequest{ + // TODO: Fill request struct fields. + } + it := c.ListDatasets(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleClient_DeleteDataset() { + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.DeleteDatasetRequest{ + // TODO: Fill request struct fields. + } + err = c.DeleteDataset(ctx, req) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleClient_ImportData() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ImportDataRequest{ + // TODO: Fill request struct fields. + } + op, err := c.ImportData(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_ExportData() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ExportDataRequest{ + // TODO: Fill request struct fields. + } + op, err := c.ExportData(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_GetDataItem() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.GetDataItemRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.GetDataItem(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_ListDataItems() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ListDataItemsRequest{ + // TODO: Fill request struct fields. + } + it := c.ListDataItems(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleClient_GetAnnotatedDataset() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.GetAnnotatedDatasetRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.GetAnnotatedDataset(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_ListAnnotatedDatasets() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ListAnnotatedDatasetsRequest{ + // TODO: Fill request struct fields. + } + it := c.ListAnnotatedDatasets(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleClient_DeleteAnnotatedDataset() { + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.DeleteAnnotatedDatasetRequest{ + // TODO: Fill request struct fields. + } + err = c.DeleteAnnotatedDataset(ctx, req) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleClient_LabelImage() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.LabelImageRequest{ + // TODO: Fill request struct fields. + } + op, err := c.LabelImage(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_LabelVideo() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.LabelVideoRequest{ + // TODO: Fill request struct fields. + } + op, err := c.LabelVideo(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_LabelText() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.LabelTextRequest{ + // TODO: Fill request struct fields. + } + op, err := c.LabelText(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_GetExample() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.GetExampleRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.GetExample(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_ListExamples() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ListExamplesRequest{ + // TODO: Fill request struct fields. + } + it := c.ListExamples(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleClient_CreateAnnotationSpecSet() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.CreateAnnotationSpecSetRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.CreateAnnotationSpecSet(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_GetAnnotationSpecSet() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.GetAnnotationSpecSetRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.GetAnnotationSpecSet(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_ListAnnotationSpecSets() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ListAnnotationSpecSetsRequest{ + // TODO: Fill request struct fields. + } + it := c.ListAnnotationSpecSets(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleClient_DeleteAnnotationSpecSet() { + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.DeleteAnnotationSpecSetRequest{ + // TODO: Fill request struct fields. + } + err = c.DeleteAnnotationSpecSet(ctx, req) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleClient_CreateInstruction() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.CreateInstructionRequest{ + // TODO: Fill request struct fields. + } + op, err := c.CreateInstruction(ctx, req) + if err != nil { + // TODO: Handle error. + } + + resp, err := op.Wait(ctx) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_GetInstruction() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.GetInstructionRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.GetInstruction(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_ListInstructions() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ListInstructionsRequest{ + // TODO: Fill request struct fields. + } + it := c.ListInstructions(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleClient_DeleteInstruction() { + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.DeleteInstructionRequest{ + // TODO: Fill request struct fields. + } + err = c.DeleteInstruction(ctx, req) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleClient_GetEvaluation() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.GetEvaluationRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.GetEvaluation(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_SearchEvaluations() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.SearchEvaluationsRequest{ + // TODO: Fill request struct fields. + } + it := c.SearchEvaluations(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleClient_SearchExampleComparisons() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.SearchExampleComparisonsRequest{ + // TODO: Fill request struct fields. + } + it := c.SearchExampleComparisons(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} + +func ExampleClient_CreateEvaluationJob() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.CreateEvaluationJobRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.CreateEvaluationJob(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_UpdateEvaluationJob() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.UpdateEvaluationJobRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.UpdateEvaluationJob(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_GetEvaluationJob() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.GetEvaluationJobRequest{ + // TODO: Fill request struct fields. + } + resp, err := c.GetEvaluationJob(ctx, req) + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp +} + +func ExampleClient_PauseEvaluationJob() { + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.PauseEvaluationJobRequest{ + // TODO: Fill request struct fields. + } + err = c.PauseEvaluationJob(ctx, req) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleClient_ResumeEvaluationJob() { + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ResumeEvaluationJobRequest{ + // TODO: Fill request struct fields. + } + err = c.ResumeEvaluationJob(ctx, req) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleClient_DeleteEvaluationJob() { + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.DeleteEvaluationJobRequest{ + // TODO: Fill request struct fields. + } + err = c.DeleteEvaluationJob(ctx, req) + if err != nil { + // TODO: Handle error. + } +} + +func ExampleClient_ListEvaluationJobs() { + // import datalabelingpb "google.golang.org/genproto/googleapis/cloud/datalabeling/v1beta1" + // import "google.golang.org/api/iterator" + + ctx := context.Background() + c, err := datalabeling.NewClient(ctx) + if err != nil { + // TODO: Handle error. + } + + req := &datalabelingpb.ListEvaluationJobsRequest{ + // TODO: Fill request struct fields. + } + it := c.ListEvaluationJobs(ctx, req) + for { + resp, err := it.Next() + if err == iterator.Done { + break + } + if err != nil { + // TODO: Handle error. + } + // TODO: Use resp. + _ = resp + } +} diff --git a/datalabeling/apiv1beta1/doc.go b/datalabeling/apiv1beta1/doc.go new file mode 100644 index 00000000000..77743dcf2e1 --- /dev/null +++ b/datalabeling/apiv1beta1/doc.go @@ -0,0 +1,116 @@ +// Copyright 2021 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Code generated by protoc-gen-go_gapic. DO NOT EDIT. + +// Package datalabeling is an auto-generated package for the +// Data Labeling API. +// +// Public API for Google Cloud AI Data Labeling Service. +// +// Use of Context +// +// The ctx passed to NewClient is used for authentication requests and +// for creating the underlying connection, but is not used for subsequent calls. +// Individual methods on the client use the ctx given to them. +// +// To close the open connection, use the Close() method. +// +// For information about setting deadlines, reusing contexts, and more +// please visit pkg.go.dev/cloud.google.com/go. +package datalabeling // import "cloud.google.com/go/datalabeling/apiv1beta1" + +import ( + "context" + "os" + "runtime" + "strconv" + "strings" + "unicode" + + "google.golang.org/api/option" + "google.golang.org/grpc/metadata" +) + +// For more information on implementing a client constructor hook, see +// https://github.com/googleapis/google-cloud-go/wiki/Customizing-constructors. +type clientHookParams struct{} +type clientHook func(context.Context, clientHookParams) ([]option.ClientOption, error) + +const versionClient = "20210120" + +func insertMetadata(ctx context.Context, mds ...metadata.MD) context.Context { + out, _ := metadata.FromOutgoingContext(ctx) + out = out.Copy() + for _, md := range mds { + for k, v := range md { + out[k] = append(out[k], v...) + } + } + return metadata.NewOutgoingContext(ctx, out) +} + +func checkDisableDeadlines() (bool, error) { + raw, ok := os.LookupEnv("GOOGLE_API_GO_EXPERIMENTAL_DISABLE_DEFAULT_DEADLINE") + if !ok { + return false, nil + } + + b, err := strconv.ParseBool(raw) + return b, err +} + +// DefaultAuthScopes reports the default set of authentication scopes to use with this package. +func DefaultAuthScopes() []string { + return []string{ + "https://www.googleapis.com/auth/cloud-platform", + } +} + +// versionGo returns the Go runtime version. The returned string +// has no whitespace, suitable for reporting in header. +func versionGo() string { + const develPrefix = "devel +" + + s := runtime.Version() + if strings.HasPrefix(s, develPrefix) { + s = s[len(develPrefix):] + if p := strings.IndexFunc(s, unicode.IsSpace); p >= 0 { + s = s[:p] + } + return s + } + + notSemverRune := func(r rune) bool { + return !strings.ContainsRune("0123456789.", r) + } + + if strings.HasPrefix(s, "go1") { + s = s[2:] + var prerelease string + if p := strings.IndexFunc(s, notSemverRune); p >= 0 { + s, prerelease = s[:p], s[p:] + } + if strings.HasSuffix(s, ".") { + s += "0" + } else if strings.Count(s, ".") < 2 { + s += ".0" + } + if prerelease != "" { + s += "-" + prerelease + } + return s + } + return "UNKNOWN" +} diff --git a/internal/.repo-metadata-full.json b/internal/.repo-metadata-full.json index 0aaffcd7b10..228fdf818e0 100644 --- a/internal/.repo-metadata-full.json +++ b/internal/.repo-metadata-full.json @@ -287,6 +287,14 @@ "docs_url": "https://pkg.go.dev/cloud.google.com/go/datacatalog/apiv1beta1", "release_level": "beta" }, + "cloud.google.com/go/datalabeling/apiv1beta1": { + "distribution_name": "cloud.google.com/go/datalabeling/apiv1beta1", + "description": "Data Labeling API", + "language": "Go", + "client_library_type": "generated", + "docs_url": "https://pkg.go.dev/cloud.google.com/go/datalabeling/apiv1beta1", + "release_level": "beta" + }, "cloud.google.com/go/dataproc/apiv1": { "distribution_name": "cloud.google.com/go/dataproc/apiv1", "description": "Cloud Dataproc API", diff --git a/internal/gapicgen/generator/config.go b/internal/gapicgen/generator/config.go index d0ecf4b87d3..0abe11e99f7 100644 --- a/internal/gapicgen/generator/config.go +++ b/internal/gapicgen/generator/config.go @@ -916,6 +916,14 @@ var microgenGapicConfigs = []*microgenConfig{ // GA after 2021/02/19 releaseLevel: "beta", }, + { + inputDirectoryPath: "google/cloud/datalabeling/v1beta1", + pkg: "datalabeling", + importPath: "cloud.google.com/go/datalabeling/apiv1beta1", + gRPCServiceConfigPath: "google/cloud/datalabeling/v1beta1/datalabeling_grpc_service_config.json", + apiServiceConfigPath: "google/cloud/datalabeling/v1beta1/datalabeling_v1beta1.yaml", + releaseLevel: "beta", + }, // Non-Cloud APIs {