// Package genomics provides access to the Genomics API. // // Usage example: // // import "google.golang.org/api/genomics/v1alpha2" // ... // genomicsService, err := genomics.New(oauthHttpClient) package genomics // import "google.golang.org/api/genomics/v1alpha2" import ( "bytes" "encoding/json" "errors" "fmt" context "golang.org/x/net/context" ctxhttp "golang.org/x/net/context/ctxhttp" gensupport "google.golang.org/api/gensupport" googleapi "google.golang.org/api/googleapi" "io" "net/http" "net/url" "strconv" "strings" ) // Always reference these packages, just in case the auto-generated code // below doesn't. var _ = bytes.NewBuffer var _ = strconv.Itoa var _ = fmt.Sprintf var _ = json.NewDecoder var _ = io.Copy var _ = url.Parse var _ = gensupport.MarshalJSON var _ = googleapi.Version var _ = errors.New var _ = strings.Replace var _ = context.Canceled var _ = ctxhttp.Do const apiId = "genomics:v1alpha2" const apiName = "genomics" const apiVersion = "v1alpha2" const basePath = "https://genomics.googleapis.com/" // OAuth2 scopes used by this API. const ( // View and manage your data across Google Cloud Platform services CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" // View and manage Genomics data GenomicsScope = "https://www.googleapis.com/auth/genomics" ) func New(client *http.Client) (*Service, error) { if client == nil { return nil, errors.New("client is nil") } s := &Service{client: client, BasePath: basePath} s.Operations = NewOperationsService(s) return s, nil } type Service struct { client *http.Client BasePath string // API endpoint base URL UserAgent string // optional additional User-Agent fragment Operations *OperationsService } func (s *Service) userAgent() string { if s.UserAgent == "" { return googleapi.UserAgent } return googleapi.UserAgent + " " + s.UserAgent } func NewOperationsService(s *Service) *OperationsService { rs := &OperationsService{s: s} return rs } type OperationsService struct { s *Service } // CancelOperationRequest: The request message for // Operations.CancelOperation. type CancelOperationRequest struct { } // Empty: A generic empty message that you can re-use to avoid defining // duplicated empty messages in your APIs. A typical example is to use // it as the request or the response type of an API method. For // instance: service Foo { rpc Bar(google.protobuf.Empty) returns // (google.protobuf.Empty); } The JSON representation for `Empty` is // empty JSON object `{}`. type Empty struct { // ServerResponse contains the HTTP response code and headers from the // server. googleapi.ServerResponse `json:"-"` } // ImportReadGroupSetsResponse: The read group set import response. type ImportReadGroupSetsResponse struct { // ReadGroupSetIds: IDs of the read group sets that were created. ReadGroupSetIds []string `json:"readGroupSetIds,omitempty"` // ForceSendFields is a list of field names (e.g. "ReadGroupSetIds") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *ImportReadGroupSetsResponse) MarshalJSON() ([]byte, error) { type noMethod ImportReadGroupSetsResponse raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } // ImportVariantsResponse: The variant data import response. type ImportVariantsResponse struct { // CallSetIds: IDs of the call sets created during the import. CallSetIds []string `json:"callSetIds,omitempty"` // ForceSendFields is a list of field names (e.g. "CallSetIds") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *ImportVariantsResponse) MarshalJSON() ([]byte, error) { type noMethod ImportVariantsResponse raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } // ListOperationsResponse: The response message for // Operations.ListOperations. type ListOperationsResponse struct { // NextPageToken: The standard List next-page token. NextPageToken string `json:"nextPageToken,omitempty"` // Operations: A list of operations that matches the specified filter in // the request. Operations []*Operation `json:"operations,omitempty"` // ServerResponse contains the HTTP response code and headers from the // server. googleapi.ServerResponse `json:"-"` // ForceSendFields is a list of field names (e.g. "NextPageToken") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) { type noMethod ListOperationsResponse raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } // Operation: This resource represents a long-running operation that is // the result of a network API call. type Operation struct { // Done: If the value is `false`, it means the operation is still in // progress. If true, the operation is completed, and either `error` or // `response` is available. Done bool `json:"done,omitempty"` // Error: The error result of the operation in case of failure. Error *Status `json:"error,omitempty"` // Metadata: An OperationMetadata object. This will always be returned // with the Operation. Metadata OperationMetadata `json:"metadata,omitempty"` // Name: The server-assigned name, which is only unique within the same // service that originally returns it. For example: // `operations/CJHU7Oi_ChDrveSpBRjfuL-qzoWAgEw` Name string `json:"name,omitempty"` // Response: If importing ReadGroupSets, an ImportReadGroupSetsResponse // is returned. If importing Variants, an ImportVariantsResponse is // returned. For exports, an empty response is returned. Response OperationResponse `json:"response,omitempty"` // ServerResponse contains the HTTP response code and headers from the // server. googleapi.ServerResponse `json:"-"` // ForceSendFields is a list of field names (e.g. "Done") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *Operation) MarshalJSON() ([]byte, error) { type noMethod Operation raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } type OperationMetadata interface{} type OperationResponse interface{} // OperationEvent: An event that occurred during an Operation. type OperationEvent struct { // Description: Required description of event. Description string `json:"description,omitempty"` // ForceSendFields is a list of field names (e.g. "Description") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *OperationEvent) MarshalJSON() ([]byte, error) { type noMethod OperationEvent raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } // OperationMetadata1: Metadata describing an Operation. type OperationMetadata1 struct { // CreateTime: The time at which the job was submitted to the Genomics // service. CreateTime string `json:"createTime,omitempty"` // Events: Optional event messages that were generated during the job's // execution. This also contains any warnings that were generated during // import or export. Events []*OperationEvent `json:"events,omitempty"` // ProjectId: The Google Cloud Project in which the job is scoped. ProjectId string `json:"projectId,omitempty"` // Request: The original request that started the operation. Note that // this will be in current version of the API. If the operation was // started with v1beta2 API and a GetOperation is performed on v1 API, a // v1 request will be returned. Request OperationMetadataRequest `json:"request,omitempty"` // ForceSendFields is a list of field names (e.g. "CreateTime") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *OperationMetadata1) MarshalJSON() ([]byte, error) { type noMethod OperationMetadata1 raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } type OperationMetadataRequest interface{} // Status: The `Status` type defines a logical error model that is // suitable for different programming environments, including REST APIs // and RPC APIs. It is used by [gRPC](https://github.com/grpc). The // error model is designed to be: - Simple to use and understand for // most users - Flexible enough to meet unexpected needs # Overview The // `Status` message contains three pieces of data: error code, error // message, and error details. The error code should be an enum value of // google.rpc.Code, but it may accept additional error codes if needed. // The error message should be a developer-facing English message that // helps developers *understand* and *resolve* the error. If a localized // user-facing error message is needed, put the localized message in the // error details or localize it in the client. The optional error // details may contain arbitrary information about the error. There is a // predefined set of error detail types in the package `google.rpc` // which can be used for common error conditions. # Language mapping The // `Status` message is the logical representation of the error model, // but it is not necessarily the actual wire format. When the `Status` // message is exposed in different client libraries and different wire // protocols, it can be mapped differently. For example, it will likely // be mapped to some exceptions in Java, but more likely mapped to some // error codes in C. # Other uses The error model and the `Status` // message can be used in a variety of environments, either with or // without APIs, to provide a consistent developer experience across // different environments. Example uses of this error model include: - // Partial errors. If a service needs to return partial errors to the // client, it may embed the `Status` in the normal response to indicate // the partial errors. - Workflow errors. A typical workflow has // multiple steps. Each step may have a `Status` message for error // reporting purpose. - Batch operations. If a client uses batch request // and batch response, the `Status` message should be used directly // inside batch response, one for each error sub-response. - // Asynchronous operations. If an API call embeds asynchronous operation // results in its response, the status of those operations should be // represented directly using the `Status` message. - Logging. If some // API errors are stored in logs, the message `Status` could be used // directly after any stripping needed for security/privacy reasons. type Status struct { // Code: The status code, which should be an enum value of // google.rpc.Code. Code int64 `json:"code,omitempty"` // Details: A list of messages that carry the error details. There will // be a common set of message types for APIs to use. Details []StatusDetails `json:"details,omitempty"` // Message: A developer-facing error message, which should be in // English. Any user-facing error message should be localized and sent // in the google.rpc.Status.details field, or localized by the client. Message string `json:"message,omitempty"` // ForceSendFields is a list of field names (e.g. "Code") to // unconditionally include in API requests. By default, fields with // empty values are omitted from API requests. However, any non-pointer, // non-interface field appearing in ForceSendFields will be sent to the // server regardless of whether the field is empty or not. This may be // used to include empty fields in Patch requests. ForceSendFields []string `json:"-"` } func (s *Status) MarshalJSON() ([]byte, error) { type noMethod Status raw := noMethod(*s) return gensupport.MarshalJSON(raw, s.ForceSendFields) } type StatusDetails interface{} // method id "genomics.operations.cancel": type OperationsCancelCall struct { s *Service name string canceloperationrequest *CancelOperationRequest urlParams_ gensupport.URLParams ctx_ context.Context } // Cancel: Starts asynchronous cancellation on a long-running operation. // The server makes a best effort to cancel the operation, but success // is not guaranteed. Clients may use Operations.GetOperation or // Operations.ListOperations to check whether the cancellation succeeded // or the operation completed despite cancellation. func (r *OperationsService) Cancel(name string, canceloperationrequest *CancelOperationRequest) *OperationsCancelCall { c := &OperationsCancelCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.name = name c.canceloperationrequest = canceloperationrequest return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *OperationsCancelCall) Fields(s ...googleapi.Field) *OperationsCancelCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *OperationsCancelCall) Context(ctx context.Context) *OperationsCancelCall { c.ctx_ = ctx return c } func (c *OperationsCancelCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil body, err := googleapi.WithoutDataWrapper.JSONReader(c.canceloperationrequest) if err != nil { return nil, err } ctype := "application/json" c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/{+name}:cancel") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("POST", urls, body) googleapi.Expand(req.URL, map[string]string{ "name": c.name, }) req.Header.Set("Content-Type", ctype) req.Header.Set("User-Agent", c.s.userAgent()) if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "genomics.operations.cancel" call. // Exactly one of *Empty or error will be non-nil. Any non-2xx status // code is an error. Response headers are in either // *Empty.ServerResponse.Header or (if a response was returned at all) // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to // check whether the returned error was because http.StatusNotModified // was returned. func (c *OperationsCancelCall) Do(opts ...googleapi.CallOption) (*Empty, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &Empty{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Starts asynchronous cancellation on a long-running operation. The server makes a best effort to cancel the operation, but success is not guaranteed. Clients may use Operations.GetOperation or Operations.ListOperations to check whether the cancellation succeeded or the operation completed despite cancellation.", // "httpMethod": "POST", // "id": "genomics.operations.cancel", // "parameterOrder": [ // "name" // ], // "parameters": { // "name": { // "description": "The name of the operation resource to be cancelled.", // "location": "path", // "pattern": "^operations/.*$", // "required": true, // "type": "string" // } // }, // "path": "v1alpha2/{+name}:cancel", // "request": { // "$ref": "CancelOperationRequest" // }, // "response": { // "$ref": "Empty" // }, // "scopes": [ // "https://www.googleapis.com/auth/cloud-platform", // "https://www.googleapis.com/auth/genomics" // ] // } } // method id "genomics.operations.get": type OperationsGetCall struct { s *Service name string urlParams_ gensupport.URLParams ifNoneMatch_ string ctx_ context.Context } // Get: Gets the latest state of a long-running operation. Clients can // use this method to poll the operation result at intervals as // recommended by the API service. func (r *OperationsService) Get(name string) *OperationsGetCall { c := &OperationsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.name = name return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *OperationsGetCall) Fields(s ...googleapi.Field) *OperationsGetCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // IfNoneMatch sets the optional parameter which makes the operation // fail if the object's ETag matches the given value. This is useful for // getting updates only after the object has changed since the last // request. Use googleapi.IsNotModified to check whether the response // error from Do is the result of In-None-Match. func (c *OperationsGetCall) IfNoneMatch(entityTag string) *OperationsGetCall { c.ifNoneMatch_ = entityTag return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *OperationsGetCall) Context(ctx context.Context) *OperationsGetCall { c.ctx_ = ctx return c } func (c *OperationsGetCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/{+name}") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("GET", urls, body) googleapi.Expand(req.URL, map[string]string{ "name": c.name, }) req.Header.Set("User-Agent", c.s.userAgent()) if c.ifNoneMatch_ != "" { req.Header.Set("If-None-Match", c.ifNoneMatch_) } if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "genomics.operations.get" call. // Exactly one of *Operation or error will be non-nil. Any non-2xx // status code is an error. Response headers are in either // *Operation.ServerResponse.Header or (if a response was returned at // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified // to check whether the returned error was because // http.StatusNotModified was returned. func (c *OperationsGetCall) Do(opts ...googleapi.CallOption) (*Operation, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &Operation{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Gets the latest state of a long-running operation. Clients can use this method to poll the operation result at intervals as recommended by the API service.", // "httpMethod": "GET", // "id": "genomics.operations.get", // "parameterOrder": [ // "name" // ], // "parameters": { // "name": { // "description": "The name of the operation resource.", // "location": "path", // "pattern": "^operations/.*$", // "required": true, // "type": "string" // } // }, // "path": "v1alpha2/{+name}", // "response": { // "$ref": "Operation" // }, // "scopes": [ // "https://www.googleapis.com/auth/cloud-platform", // "https://www.googleapis.com/auth/genomics" // ] // } } // method id "genomics.operations.list": type OperationsListCall struct { s *Service name string urlParams_ gensupport.URLParams ifNoneMatch_ string ctx_ context.Context } // List: Lists operations that match the specified filter in the // request. func (r *OperationsService) List(name string) *OperationsListCall { c := &OperationsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} c.name = name return c } // Filter sets the optional parameter "filter": A string for filtering // Operations. The following filter fields are supported: * projectId: // Required. Corresponds to OperationMetadata.projectId. * createTime: // The time this job was created, in seconds from the // [epoch](http://en.wikipedia.org/wiki/Unix_time). Can use `>=` and/or // `= 1432140000` * `projectId = my-project AND createTime >= 1432140000 // AND createTime <= 1432150000 AND status = RUNNING` func (c *OperationsListCall) Filter(filter string) *OperationsListCall { c.urlParams_.Set("filter", filter) return c } // PageSize sets the optional parameter "pageSize": The maximum number // of results to return. If unspecified, defaults to 256. The maximum // value is 2048. func (c *OperationsListCall) PageSize(pageSize int64) *OperationsListCall { c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) return c } // PageToken sets the optional parameter "pageToken": The standard list // page token. func (c *OperationsListCall) PageToken(pageToken string) *OperationsListCall { c.urlParams_.Set("pageToken", pageToken) return c } // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. func (c *OperationsListCall) Fields(s ...googleapi.Field) *OperationsListCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } // IfNoneMatch sets the optional parameter which makes the operation // fail if the object's ETag matches the given value. This is useful for // getting updates only after the object has changed since the last // request. Use googleapi.IsNotModified to check whether the response // error from Do is the result of In-None-Match. func (c *OperationsListCall) IfNoneMatch(entityTag string) *OperationsListCall { c.ifNoneMatch_ = entityTag return c } // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. func (c *OperationsListCall) Context(ctx context.Context) *OperationsListCall { c.ctx_ = ctx return c } func (c *OperationsListCall) doRequest(alt string) (*http.Response, error) { var body io.Reader = nil c.urlParams_.Set("alt", alt) urls := googleapi.ResolveRelative(c.s.BasePath, "v1alpha2/{+name}") urls += "?" + c.urlParams_.Encode() req, _ := http.NewRequest("GET", urls, body) googleapi.Expand(req.URL, map[string]string{ "name": c.name, }) req.Header.Set("User-Agent", c.s.userAgent()) if c.ifNoneMatch_ != "" { req.Header.Set("If-None-Match", c.ifNoneMatch_) } if c.ctx_ != nil { return ctxhttp.Do(c.ctx_, c.s.client, req) } return c.s.client.Do(req) } // Do executes the "genomics.operations.list" call. // Exactly one of *ListOperationsResponse or error will be non-nil. Any // non-2xx status code is an error. Response headers are in either // *ListOperationsResponse.ServerResponse.Header or (if a response was // returned at all) in error.(*googleapi.Error).Header. Use // googleapi.IsNotModified to check whether the returned error was // because http.StatusNotModified was returned. func (c *OperationsListCall) Do(opts ...googleapi.CallOption) (*ListOperationsResponse, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { if res.Body != nil { res.Body.Close() } return nil, &googleapi.Error{ Code: res.StatusCode, Header: res.Header, } } if err != nil { return nil, err } defer googleapi.CloseBody(res) if err := googleapi.CheckResponse(res); err != nil { return nil, err } ret := &ListOperationsResponse{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, }, } if err := json.NewDecoder(res.Body).Decode(&ret); err != nil { return nil, err } return ret, nil // { // "description": "Lists operations that match the specified filter in the request.", // "httpMethod": "GET", // "id": "genomics.operations.list", // "parameterOrder": [ // "name" // ], // "parameters": { // "filter": { // "description": "A string for filtering Operations. The following filter fields are supported: * projectId: Required. Corresponds to OperationMetadata.projectId. * createTime: The time this job was created, in seconds from the [epoch](http://en.wikipedia.org/wiki/Unix_time). Can use `\u003e=` and/or `= 1432140000` * `projectId = my-project AND createTime \u003e= 1432140000 AND createTime \u003c= 1432150000 AND status = RUNNING`", // "location": "query", // "type": "string" // }, // "name": { // "description": "The name of the operation collection.", // "location": "path", // "pattern": "^operations$", // "required": true, // "type": "string" // }, // "pageSize": { // "description": "The maximum number of results to return. If unspecified, defaults to 256. The maximum value is 2048.", // "format": "int32", // "location": "query", // "type": "integer" // }, // "pageToken": { // "description": "The standard list page token.", // "location": "query", // "type": "string" // } // }, // "path": "v1alpha2/{+name}", // "response": { // "$ref": "ListOperationsResponse" // }, // "scopes": [ // "https://www.googleapis.com/auth/cloud-platform", // "https://www.googleapis.com/auth/genomics" // ] // } } // Pages invokes f for each page of results. // A non-nil error returned from f will halt the iteration. // The provided context supersedes any context provided to the Context method. func (c *OperationsListCall) Pages(ctx context.Context, f func(*ListOperationsResponse) error) error { c.ctx_ = ctx defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point for { x, err := c.Do() if err != nil { return err } if err := f(x); err != nil { return err } if x.NextPageToken == "" { return nil } c.PageToken(x.NextPageToken) } }