diff --git a/.coveragerc b/.coveragerc index 2ec673d3ecd4..77dd56b8e2e8 100644 --- a/.coveragerc +++ b/.coveragerc @@ -2,6 +2,7 @@ omit = */demo/* */demo.py + */_generated/*.py exclude_lines = # Re-enable the standard pragma pragma: NO COVER diff --git a/.gitignore b/.gitignore index 8e09e0c149f3..3f9406901fd2 100644 --- a/.gitignore +++ b/.gitignore @@ -52,3 +52,7 @@ pylintrc_reduced # Travis build directories. gcloud-python-wheels/ + +# Directories used for creating generated PB2 files +generated_python/ +cloud-bigtable-client/ diff --git a/Makefile b/Makefile new file mode 100644 index 000000000000..cd37f8a0c58a --- /dev/null +++ b/Makefile @@ -0,0 +1,79 @@ +GENERATED_DIR=$(shell pwd)/generated_python +FINAL_DIR=gcloud/bigtable/_generated +BREW_PREFIX=$(shell brew --prefix) +LD_LIBRARY_PATH=$(BREW_PREFIX)/lib +GRPC_PLUGIN=$(BREW_PREFIX)/bin/grpc_python_plugin + +help: + @echo 'Makefile for gcloud-python Bigtable protos ' + @echo ' ' + @echo ' make generate Generates the protobuf modules ' + @echo ' make check_generate Checks that generate succeeded ' + @echo ' make clean Clean generated files ' + +generate: + [ -d cloud-bigtable-client ] || git clone https://github.com/GoogleCloudPlatform/cloud-bigtable-client + cd cloud-bigtable-client && git pull origin master + mkdir -p $(GENERATED_DIR) + # Data API + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) google/bigtable/v1/*.proto + mv $(GENERATED_DIR)/google/bigtable/v1/* $(FINAL_DIR) + # Cluster API + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/bigtable/admin/cluster/v1/*.proto + mv $(GENERATED_DIR)/google/bigtable/admin/cluster/v1/* $(FINAL_DIR) + # Table API + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/bigtable/admin/table/v1/*.proto + mv $(GENERATED_DIR)/google/bigtable/admin/table/v1/* $(FINAL_DIR) + # Auxiliary protos + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/api/*.proto + mv $(GENERATED_DIR)/google/api/* $(FINAL_DIR) + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/protobuf/any.proto + mv $(GENERATED_DIR)/google/protobuf/any_pb2.py $(FINAL_DIR) + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/protobuf/duration.proto + mv $(GENERATED_DIR)/google/protobuf/duration_pb2.py $(FINAL_DIR) + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/protobuf/empty.proto + mv $(GENERATED_DIR)/google/protobuf/empty_pb2.py $(FINAL_DIR) + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/protobuf/timestamp.proto + mv $(GENERATED_DIR)/google/protobuf/timestamp_pb2.py $(FINAL_DIR) + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/longrunning/operations.proto + mv $(GENERATED_DIR)/google/longrunning/operations_pb2.py $(FINAL_DIR) + cd cloud-bigtable-client/bigtable-protos/src/main/proto && \ + protoc --python_out=$(GENERATED_DIR) --grpc_out=$(GENERATED_DIR) \ + --plugin=protoc-gen-grpc=$(GRPC_PLUGIN) \ + google/rpc/status.proto + mv $(GENERATED_DIR)/google/rpc/status_pb2.py $(FINAL_DIR) + python scripts/rewrite_imports.py + +check_generate: + python scripts/check_generate.py + +clean: + rm -fr cloud-bigtable-client $(GENERATED_DIR) + +.PHONY: generate check_generate clean diff --git a/gcloud/bigtable/_generated/__init__.py b/gcloud/bigtable/_generated/__init__.py new file mode 100644 index 000000000000..ad35adcf05ae --- /dev/null +++ b/gcloud/bigtable/_generated/__init__.py @@ -0,0 +1,15 @@ +# Copyright 2015 Google Inc. All rights reserved. +# +# 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 +# +# http://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. + +"""Generated protobuf modules for Google Cloud Bigtable API.""" diff --git a/gcloud/bigtable/_generated/_annotations.proto b/gcloud/bigtable/_generated/_annotations.proto new file mode 100755 index 000000000000..cbd18b847f39 --- /dev/null +++ b/gcloud/bigtable/_generated/_annotations.proto @@ -0,0 +1,29 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.api; + +import "google/api/http.proto"; +import "google/protobuf/descriptor.proto"; + +option java_multiple_files = true; +option java_outer_classname = "AnnotationsProto"; +option java_package = "com.google.api"; + +extend google.protobuf.MethodOptions { + // See `HttpRule`. + HttpRule http = 72295728; +} diff --git a/gcloud/bigtable/_generated/_any.proto b/gcloud/bigtable/_generated/_any.proto new file mode 100755 index 000000000000..7c79e5768602 --- /dev/null +++ b/gcloud/bigtable/_generated/_any.proto @@ -0,0 +1,87 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.protobuf; + +option java_generate_equals_and_hash = true; +option java_multiple_files = true; +option java_outer_classname = "AnyProto"; +option java_package = "com.google.protobuf"; + + +// `Any` contains an arbitrary serialized message along with a URL +// that describes the type of the serialized message. +// +// The proto runtimes and/or compiler will eventually +// provide utilities to pack/unpack Any values (projected Q1/15). +// +// # JSON +// The JSON representation of an `Any` value uses the regular +// representation of the deserialized, embedded message, with an +// additional field `@type` which contains the type URL. Example: +// +// package google.profile; +// message Person { +// string first_name = 1; +// string last_name = 2; +// } +// +// { +// "@type": "type.googleapis.com/google.profile.Person", +// "firstName": , +// "lastName": +// } +// +// If the embedded message type is well-known and has a custom JSON +// representation, that representation will be embedded adding a field +// `value` which holds the custom JSON in addition to the the `@type` +// field. Example (for message [google.protobuf.Duration][google.protobuf.Duration]): +// +// { +// "@type": "type.googleapis.com/google.protobuf.Duration", +// "value": "1.212s" +// } +// +message Any { + // A URL/resource name whose content describes the type of the + // serialized message. + // + // For URLs which use the schema `http`, `https`, or no schema, the + // following restrictions and interpretations apply: + // + // * If no schema is provided, `https` is assumed. + // * The last segment of the URL's path must represent the fully + // qualified name of the type (as in `path/google.protobuf.Duration`). + // * An HTTP GET on the URL must yield a [google.protobuf.Type][google.protobuf.Type] + // value in binary format, or produce an error. + // * Applications are allowed to cache lookup results based on the + // URL, or have them precompiled into a binary to avoid any + // lookup. Therefore, binary compatibility needs to be preserved + // on changes to types. (Use versioned type names to manage + // breaking changes.) + // + // Schemas other than `http`, `https` (or the empty schema) might be + // used with implementation specific semantics. + // + // Types originating from the `google.*` package + // namespace should use `type.googleapis.com/full.type.name` (without + // schema and path). A type service will eventually become available which + // serves those URLs (projected Q2/15). + string type_url = 1; + + // Must be valid serialized data of the above specified type. + bytes value = 2; +} diff --git a/gcloud/bigtable/_generated/_bigtable_cluster_data.proto b/gcloud/bigtable/_generated/_bigtable_cluster_data.proto new file mode 100755 index 000000000000..cbebe186dd64 --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_cluster_data.proto @@ -0,0 +1,94 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.admin.cluster.v1; + +import "google/api/annotations.proto"; +import "google/longrunning/operations.proto"; +import "google/protobuf/timestamp.proto"; + +option java_multiple_files = true; +option java_outer_classname = "BigtableClusterDataProto"; +option java_package = "com.google.bigtable.admin.cluster.v1"; + + +// A physical location in which a particular project can allocate Cloud BigTable +// resources. +message Zone { + // Possible states of a zone. + enum Status { + // The state of the zone is unknown or unspecified. + UNKNOWN = 0; + + // The zone is in a good state. + OK = 1; + + // The zone is down for planned maintenance. + PLANNED_MAINTENANCE = 2; + + // The zone is down for emergency or unplanned maintenance. + EMERGENCY_MAINENANCE = 3; + } + + // A permanent unique identifier for the zone. + // Values are of the form projects//zones/[a-z][-a-z0-9]* + string name = 1; + + // The name of this zone as it appears in UIs. + string display_name = 2; + + // The current state of this zone. + Status status = 3; +} + +// An isolated set of Cloud BigTable resources on which tables can be hosted. +message Cluster { + // A permanent unique identifier for the cluster. For technical reasons, the + // zone in which the cluster resides is included here. + // Values are of the form + // projects//zones//clusters/[a-z][-a-z0-9]* + string name = 1; + + // If this cluster has been deleted, the time at which its backup will + // be irrevocably destroyed. Omitted otherwise. + // This cannot be set directly, only through DeleteCluster. + google.protobuf.Timestamp delete_time = 2; + + // The operation currently running on the cluster, if any. + // This cannot be set directly, only through CreateCluster, UpdateCluster, + // or UndeleteCluster. Calls to these methods will be rejected if + // "current_operation" is already set. + google.longrunning.Operation current_operation = 3; + + // The descriptive name for this cluster as it appears in UIs. + // Must be unique per zone. + string display_name = 4; + + // The number of serve nodes allocated to this cluster. + int32 serve_nodes = 5; + + // What storage type to use for tables in this cluster. Only configurable at + // cluster creation time. If unspecified, STORAGE_SSD will be used. + StorageType default_storage_type = 8; +} + +enum StorageType { + // The storage type used is unspecified. + STORAGE_UNSPECIFIED = 0; + + // Data will be stored in SSD, providing low and consistent latencies. + STORAGE_SSD = 1; +} diff --git a/gcloud/bigtable/_generated/_bigtable_cluster_service.proto b/gcloud/bigtable/_generated/_bigtable_cluster_service.proto new file mode 100755 index 000000000000..e65bca4de740 --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_cluster_service.proto @@ -0,0 +1,129 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.admin.cluster.v1; + +import "google/api/annotations.proto"; +import "google/bigtable/admin/cluster/v1/bigtable_cluster_data.proto"; +import "google/bigtable/admin/cluster/v1/bigtable_cluster_service_messages.proto"; +import "google/longrunning/operations.proto"; +import "google/protobuf/empty.proto"; + +option java_multiple_files = true; +option java_outer_classname = "BigtableClusterServicesProto"; +option java_package = "com.google.bigtable.admin.cluster.v1"; + + +// Service for managing zonal Cloud Bigtable resources. +service BigtableClusterService { + // Lists the supported zones for the given project. + rpc ListZones(ListZonesRequest) returns (ListZonesResponse) { + option (google.api.http) = { get: "/v1/{name=projects/*}/zones" }; + } + + // Gets information about a particular cluster. + rpc GetCluster(GetClusterRequest) returns (Cluster) { + option (google.api.http) = { get: "/v1/{name=projects/*/zones/*/clusters/*}" }; + } + + // Lists all clusters in the given project, along with any zones for which + // cluster information could not be retrieved. + rpc ListClusters(ListClustersRequest) returns (ListClustersResponse) { + option (google.api.http) = { get: "/v1/{name=projects/*}/aggregated/clusters" }; + } + + // Creates a cluster and begins preparing it to begin serving. The returned + // cluster embeds as its "current_operation" a long-running operation which + // can be used to track the progress of turning up the new cluster. + // Immediately upon completion of this request: + // * The cluster will be readable via the API, with all requested attributes + // but no allocated resources. + // Until completion of the embedded operation: + // * Cancelling the operation will render the cluster immediately unreadable + // via the API. + // * All other attempts to modify or delete the cluster will be rejected. + // Upon completion of the embedded operation: + // * Billing for all successfully-allocated resources will begin (some types + // may have lower than the requested levels). + // * New tables can be created in the cluster. + // * The cluster's allocated resource levels will be readable via the API. + // The embedded operation's "metadata" field type is + // [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata] The embedded operation's "response" field type is + // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful. + rpc CreateCluster(CreateClusterRequest) returns (Cluster) { + option (google.api.http) = { post: "/v1/{name=projects/*/zones/*}/clusters" body: "*" }; + } + + // Updates a cluster, and begins allocating or releasing resources as + // requested. The returned cluster embeds as its "current_operation" a + // long-running operation which can be used to track the progress of updating + // the cluster. + // Immediately upon completion of this request: + // * For resource types where a decrease in the cluster's allocation has been + // requested, billing will be based on the newly-requested level. + // Until completion of the embedded operation: + // * Cancelling the operation will set its metadata's "cancelled_at_time", + // and begin restoring resources to their pre-request values. The operation + // is guaranteed to succeed at undoing all resource changes, after which + // point it will terminate with a CANCELLED status. + // * All other attempts to modify or delete the cluster will be rejected. + // * Reading the cluster via the API will continue to give the pre-request + // resource levels. + // Upon completion of the embedded operation: + // * Billing will begin for all successfully-allocated resources (some types + // may have lower than the requested levels). + // * All newly-reserved resources will be available for serving the cluster's + // tables. + // * The cluster's new resource levels will be readable via the API. + // [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata] The embedded operation's "response" field type is + // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful. + rpc UpdateCluster(Cluster) returns (Cluster) { + option (google.api.http) = { put: "/v1/{name=projects/*/zones/*/clusters/*}" body: "*" }; + } + + // Marks a cluster and all of its tables for permanent deletion in 7 days. + // Immediately upon completion of the request: + // * Billing will cease for all of the cluster's reserved resources. + // * The cluster's "delete_time" field will be set 7 days in the future. + // Soon afterward: + // * All tables within the cluster will become unavailable. + // Prior to the cluster's "delete_time": + // * The cluster can be recovered with a call to UndeleteCluster. + // * All other attempts to modify or delete the cluster will be rejected. + // At the cluster's "delete_time": + // * The cluster and *all of its tables* will immediately and irrevocably + // disappear from the API, and their data will be permanently deleted. + rpc DeleteCluster(DeleteClusterRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { delete: "/v1/{name=projects/*/zones/*/clusters/*}" }; + } + + // Cancels the scheduled deletion of an cluster and begins preparing it to + // resume serving. The returned operation will also be embedded as the + // cluster's "current_operation". + // Immediately upon completion of this request: + // * The cluster's "delete_time" field will be unset, protecting it from + // automatic deletion. + // Until completion of the returned operation: + // * The operation cannot be cancelled. + // Upon completion of the returned operation: + // * Billing for the cluster's resources will resume. + // * All tables within the cluster will be available. + // [UndeleteClusterMetadata][google.bigtable.admin.cluster.v1.UndeleteClusterMetadata] The embedded operation's "response" field type is + // [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful. + rpc UndeleteCluster(UndeleteClusterRequest) returns (google.longrunning.Operation) { + option (google.api.http) = { post: "/v1/{name=projects/*/zones/*/clusters/*}:undelete" body: "null" }; + } +} diff --git a/gcloud/bigtable/_generated/_bigtable_cluster_service_messages.proto b/gcloud/bigtable/_generated/_bigtable_cluster_service_messages.proto new file mode 100755 index 000000000000..3291969375c5 --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_cluster_service_messages.proto @@ -0,0 +1,134 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.admin.cluster.v1; + +import "google/bigtable/admin/cluster/v1/bigtable_cluster_data.proto"; +import "google/protobuf/timestamp.proto"; + +option java_multiple_files = true; +option java_outer_classname = "BigtableClusterServiceMessagesProto"; +option java_package = "com.google.bigtable.admin.cluster.v1"; + + +// Request message for BigtableClusterService.ListZones. +message ListZonesRequest { + // The unique name of the project for which a list of supported zones is + // requested. + // Values are of the form projects/ + string name = 1; +} + +// Response message for BigtableClusterService.ListZones. +message ListZonesResponse { + // The list of requested zones. + repeated Zone zones = 1; +} + +// Request message for BigtableClusterService.GetCluster. +message GetClusterRequest { + // The unique name of the requested cluster. + // Values are of the form projects//zones//clusters/ + string name = 1; +} + +// Request message for BigtableClusterService.ListClusters. +message ListClustersRequest { + // The unique name of the project for which a list of clusters is requested. + // Values are of the form projects/ + string name = 1; +} + +// Response message for BigtableClusterService.ListClusters. +message ListClustersResponse { + // The list of requested Clusters. + repeated Cluster clusters = 1; + + // The zones for which clusters could not be retrieved. + repeated Zone failed_zones = 2; +} + +// Request message for BigtableClusterService.CreateCluster. +message CreateClusterRequest { + // The unique name of the zone in which to create the cluster. + // Values are of the form projects//zones/ + string name = 1; + + // The id to be used when referring to the new cluster within its zone, + // e.g. just the "test-cluster" section of the full name + // "projects//zones//clusters/test-cluster". + string cluster_id = 2; + + // The cluster to create. + // The "name", "delete_time", and "current_operation" fields must be left + // blank. + Cluster cluster = 3; +} + +// Metadata type for the operation returned by +// BigtableClusterService.CreateCluster. +message CreateClusterMetadata { + // The request which prompted the creation of this operation. + CreateClusterRequest original_request = 1; + + // The time at which original_request was received. + google.protobuf.Timestamp request_time = 2; + + // The time at which this operation failed or was completed successfully. + google.protobuf.Timestamp finish_time = 3; +} + +// Metadata type for the operation returned by +// BigtableClusterService.UpdateCluster. +message UpdateClusterMetadata { + // The request which prompted the creation of this operation. + Cluster original_request = 1; + + // The time at which original_request was received. + google.protobuf.Timestamp request_time = 2; + + // The time at which this operation was cancelled. If set, this operation is + // in the process of undoing itself (which is guaranteed to succeed) and + // cannot be cancelled again. + google.protobuf.Timestamp cancel_time = 3; + + // The time at which this operation failed or was completed successfully. + google.protobuf.Timestamp finish_time = 4; +} + +// Request message for BigtableClusterService.DeleteCluster. +message DeleteClusterRequest { + // The unique name of the cluster to be deleted. + // Values are of the form projects//zones//clusters/ + string name = 1; +} + +// Request message for BigtableClusterService.UndeleteCluster. +message UndeleteClusterRequest { + // The unique name of the cluster to be un-deleted. + // Values are of the form projects//zones//clusters/ + string name = 1; +} + +// Metadata type for the operation returned by +// BigtableClusterService.UndeleteCluster. +message UndeleteClusterMetadata { + // The time at which the original request was received. + google.protobuf.Timestamp request_time = 1; + + // The time at which this operation failed or was completed successfully. + google.protobuf.Timestamp finish_time = 2; +} diff --git a/gcloud/bigtable/_generated/_bigtable_data.proto b/gcloud/bigtable/_generated/_bigtable_data.proto new file mode 100755 index 000000000000..86234d22d595 --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_data.proto @@ -0,0 +1,500 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.v1; + +option java_multiple_files = true; +option java_outer_classname = "BigtableDataProto"; +option java_package = "com.google.bigtable.v1"; + + +// Specifies the complete (requested) contents of a single row of a table. +// Rows which exceed 256MiB in size cannot be read in full. +message Row { + // The unique key which identifies this row within its table. This is the same + // key that's used to identify the row in, for example, a MutateRowRequest. + // May contain any non-empty byte string up to 4KiB in length. + bytes key = 1; + + // May be empty, but only if the entire row is empty. + // The mutual ordering of column families is not specified. + repeated Family families = 2; +} + +// Specifies (some of) the contents of a single row/column family of a table. +message Family { + // The unique key which identifies this family within its row. This is the + // same key that's used to identify the family in, for example, a RowFilter + // which sets its "family_name_regex_filter" field. + // Must match [-_.a-zA-Z0-9]+, except that AggregatingRowProcessors may + // produce cells in a sentinel family with an empty name. + // Must be no greater than 64 characters in length. + string name = 1; + + // Must not be empty. Sorted in order of increasing "qualifier". + repeated Column columns = 2; +} + +// Specifies (some of) the contents of a single row/column of a table. +message Column { + // The unique key which identifies this column within its family. This is the + // same key that's used to identify the column in, for example, a RowFilter + // which sets its "column_qualifier_regex_filter" field. + // May contain any byte string, including the empty string, up to 16kiB in + // length. + bytes qualifier = 1; + + // Must not be empty. Sorted in order of decreasing "timestamp_micros". + repeated Cell cells = 2; +} + +// Specifies (some of) the contents of a single row/column/timestamp of a table. +message Cell { + // The cell's stored timestamp, which also uniquely identifies it within + // its column. + // Values are always expressed in microseconds, but individual tables may set + // a coarser "granularity" to further restrict the allowed values. For + // example, a table which specifies millisecond granularity will only allow + // values of "timestamp_micros" which are multiples of 1000. + int64 timestamp_micros = 1; + + // The value stored in the cell. + // May contain any byte string, including the empty string, up to 100MiB in + // length. + bytes value = 2; + + // Labels applied to the cell by a [RowFilter][google.bigtable.v1.RowFilter]. + repeated string labels = 3; +} + +// Specifies a contiguous range of rows. +message RowRange { + // Inclusive lower bound. If left empty, interpreted as the empty string. + bytes start_key = 2; + + // Exclusive upper bound. If left empty, interpreted as infinity. + bytes end_key = 3; +} + +// Specifies a contiguous range of columns within a single column family. +// The range spans from : to +// :, where both bounds can be either inclusive or +// exclusive. +message ColumnRange { + // The name of the column family within which this range falls. + string family_name = 1; + + // The column qualifier at which to start the range (within 'column_family'). + // If neither field is set, interpreted as the empty string, inclusive. + oneof start_qualifier { + // Used when giving an inclusive lower bound for the range. + bytes start_qualifier_inclusive = 2; + + // Used when giving an exclusive lower bound for the range. + bytes start_qualifier_exclusive = 3; + } + + // The column qualifier at which to end the range (within 'column_family'). + // If neither field is set, interpreted as the infinite string, exclusive. + oneof end_qualifier { + // Used when giving an inclusive upper bound for the range. + bytes end_qualifier_inclusive = 4; + + // Used when giving an exclusive upper bound for the range. + bytes end_qualifier_exclusive = 5; + } +} + +// Specified a contiguous range of microsecond timestamps. +message TimestampRange { + // Inclusive lower bound. If left empty, interpreted as 0. + int64 start_timestamp_micros = 1; + + // Exclusive upper bound. If left empty, interpreted as infinity. + int64 end_timestamp_micros = 2; +} + +// Specifies a contiguous range of raw byte values. +message ValueRange { + // The value at which to start the range. + // If neither field is set, interpreted as the empty string, inclusive. + oneof start_value { + // Used when giving an inclusive lower bound for the range. + bytes start_value_inclusive = 1; + + // Used when giving an exclusive lower bound for the range. + bytes start_value_exclusive = 2; + } + + // The value at which to end the range. + // If neither field is set, interpreted as the infinite string, exclusive. + oneof end_value { + // Used when giving an inclusive upper bound for the range. + bytes end_value_inclusive = 3; + + // Used when giving an exclusive upper bound for the range. + bytes end_value_exclusive = 4; + } +} + +// Takes a row as input and produces an alternate view of the row based on +// specified rules. For example, a RowFilter might trim down a row to include +// just the cells from columns matching a given regular expression, or might +// return all the cells of a row but not their values. More complicated filters +// can be composed out of these components to express requests such as, "within +// every column of a particular family, give just the two most recent cells +// which are older than timestamp X." +// +// There are two broad categories of RowFilters (true filters and transformers), +// as well as two ways to compose simple filters into more complex ones +// (chains and interleaves). They work as follows: +// +// * True filters alter the input row by excluding some of its cells wholesale +// from the output row. An example of a true filter is the "value_regex_filter", +// which excludes cells whose values don't match the specified pattern. All +// regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax) +// in raw byte mode (RE2::Latin1), and are evaluated as full matches. An +// important point to keep in mind is that RE2(.) is equivalent by default to +// RE2([^\n]), meaning that it does not match newlines. When attempting to match +// an arbitrary byte, you should therefore use the escape sequence '\C', which +// may need to be further escaped as '\\C' in your client language. +// +// * Transformers alter the input row by changing the values of some of its +// cells in the output, without excluding them completely. Currently, the only +// supported transformer is the "strip_value_transformer", which replaces every +// cell's value with the empty string. +// +// * Chains and interleaves are described in more detail in the +// RowFilter.Chain and RowFilter.Interleave documentation. +// +// The total serialized size of a RowFilter message must not +// exceed 4096 bytes, and RowFilters may not be nested within each other +// (in Chains or Interleaves) to a depth of more than 20. +message RowFilter { + // A RowFilter which sends rows through several RowFilters in sequence. + message Chain { + // The elements of "filters" are chained together to process the input row: + // in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row + // The full chain is executed atomically. + repeated RowFilter filters = 1; + } + + // A RowFilter which sends each row to each of several component + // RowFilters and interleaves the results. + message Interleave { + // The elements of "filters" all process a copy of the input row, and the + // results are pooled, sorted, and combined into a single output row. + // If multiple cells are produced with the same column and timestamp, + // they will all appear in the output row in an unspecified mutual order. + // Consider the following example, with three filters: + // + // input row + // | + // ----------------------------------------------------- + // | | | + // f(0) f(1) f(2) + // | | | + // 1: foo,bar,10,x foo,bar,10,z far,bar,7,a + // 2: foo,blah,11,z far,blah,5,x far,blah,5,x + // | | | + // ----------------------------------------------------- + // | + // 1: foo,bar,10,z // could have switched with #2 + // 2: foo,bar,10,x // could have switched with #1 + // 3: foo,blah,11,z + // 4: far,bar,7,a + // 5: far,blah,5,x // identical to #6 + // 6: far,blah,5,x // identical to #5 + // All interleaved filters are executed atomically. + repeated RowFilter filters = 1; + } + + // A RowFilter which evaluates one of two possible RowFilters, depending on + // whether or not a predicate RowFilter outputs any cells from the input row. + // + // IMPORTANT NOTE: The predicate filter does not execute atomically with the + // true and false filters, which may lead to inconsistent or unexpected + // results. Additionally, Condition filters have poor performance, especially + // when filters are set for the false condition. + message Condition { + // If "predicate_filter" outputs any cells, then "true_filter" will be + // evaluated on the input row. Otherwise, "false_filter" will be evaluated. + RowFilter predicate_filter = 1; + + // The filter to apply to the input row if "predicate_filter" returns any + // results. If not provided, no results will be returned in the true case. + RowFilter true_filter = 2; + + // The filter to apply to the input row if "predicate_filter" does not + // return any results. If not provided, no results will be returned in the + // false case. + RowFilter false_filter = 3; + } + + // Which of the possible RowFilter types to apply. If none are set, this + // RowFilter returns all cells in the input row. + oneof filter { + // Applies several RowFilters to the data in sequence, progressively + // narrowing the results. + Chain chain = 1; + + // Applies several RowFilters to the data in parallel and combines the + // results. + Interleave interleave = 2; + + // Applies one of two possible RowFilters to the data based on the output of + // a predicate RowFilter. + Condition condition = 3; + + // ADVANCED USE ONLY. + // Hook for introspection into the RowFilter. Outputs all cells directly to + // the output of the read rather than to any parent filter. Consider the + // following example: + // + // Chain( + // FamilyRegex("A"), + // Interleave( + // All(), + // Chain(Label("foo"), Sink()) + // ), + // QualifierRegex("B") + // ) + // + // A,A,1,w + // A,B,2,x + // B,B,4,z + // | + // FamilyRegex("A") + // | + // A,A,1,w + // A,B,2,x + // | + // +------------+-------------+ + // | | + // All() Label(foo) + // | | + // A,A,1,w A,A,1,w,labels:[foo] + // A,B,2,x A,B,2,x,labels:[foo] + // | | + // | Sink() --------------+ + // | | | + // +------------+ x------+ A,A,1,w,labels:[foo] + // | A,B,2,x,labels:[foo] + // A,A,1,w | + // A,B,2,x | + // | | + // QualifierRegex("B") | + // | | + // A,B,2,x | + // | | + // +--------------------------------+ + // | + // A,A,1,w,labels:[foo] + // A,B,2,x,labels:[foo] // could be switched + // A,B,2,x // could be switched + // + // Despite being excluded by the qualifier filter, a copy of every cell + // that reaches the sink is present in the final result. + // + // As with an [Interleave][google.bigtable.v1.RowFilter.Interleave], + // duplicate cells are possible, and appear in an unspecified mutual order. + // In this case we have a duplicate with column "A:B" and timestamp 2, + // because one copy passed through the all filter while the other was + // passed through the label and sink. Note that one copy has label "foo", + // while the other does not. + // + // Cannot be used within the `predicate_filter`, `true_filter`, or + // `false_filter` of a [Condition][google.bigtable.v1.RowFilter.Condition]. + bool sink = 16; + + // Matches all cells, regardless of input. Functionally equivalent to + // leaving `filter` unset, but included for completeness. + bool pass_all_filter = 17; + + // Does not match any cells, regardless of input. Useful for temporarily + // disabling just part of a filter. + bool block_all_filter = 18; + + // Matches only cells from rows whose keys satisfy the given RE2 regex. In + // other words, passes through the entire row when the key matches, and + // otherwise produces an empty row. + // Note that, since row keys can contain arbitrary bytes, the '\C' escape + // sequence must be used if a true wildcard is desired. The '.' character + // will not match the new line character '\n', which may be present in a + // binary key. + bytes row_key_regex_filter = 4; + + // Matches all cells from a row with probability p, and matches no cells + // from the row with probability 1-p. + double row_sample_filter = 14; + + // Matches only cells from columns whose families satisfy the given RE2 + // regex. For technical reasons, the regex must not contain the ':' + // character, even if it is not being used as a literal. + // Note that, since column families cannot contain the new line character + // '\n', it is sufficient to use '.' as a full wildcard when matching + // column family names. + string family_name_regex_filter = 5; + + // Matches only cells from columns whose qualifiers satisfy the given RE2 + // regex. + // Note that, since column qualifiers can contain arbitrary bytes, the '\C' + // escape sequence must be used if a true wildcard is desired. The '.' + // character will not match the new line character '\n', which may be + // present in a binary qualifier. + bytes column_qualifier_regex_filter = 6; + + // Matches only cells from columns within the given range. + ColumnRange column_range_filter = 7; + + // Matches only cells with timestamps within the given range. + TimestampRange timestamp_range_filter = 8; + + // Matches only cells with values that satisfy the given regular expression. + // Note that, since cell values can contain arbitrary bytes, the '\C' escape + // sequence must be used if a true wildcard is desired. The '.' character + // will not match the new line character '\n', which may be present in a + // binary value. + bytes value_regex_filter = 9; + + // Matches only cells with values that fall within the given range. + ValueRange value_range_filter = 15; + + // Skips the first N cells of each row, matching all subsequent cells. + int32 cells_per_row_offset_filter = 10; + + // Matches only the first N cells of each row. + int32 cells_per_row_limit_filter = 11; + + // Matches only the most recent N cells within each column. For example, + // if N=2, this filter would match column "foo:bar" at timestamps 10 and 9, + // skip all earlier cells in "foo:bar", and then begin matching again in + // column "foo:bar2". + int32 cells_per_column_limit_filter = 12; + + // Replaces each cell's value with the empty string. + bool strip_value_transformer = 13; + + // Applies the given label to all cells in the output row. This allows + // the client to determine which results were produced from which part of + // the filter. + // + // Values must be at most 15 characters in length, and match the RE2 + // pattern [a-z0-9\\-]+ + // + // Due to a technical limitation, it is not currently possible to apply + // multiple labels to a cell. As a result, a Chain may have no more than + // one sub-filter which contains a apply_label_transformer. It is okay for + // an Interleave to contain multiple apply_label_transformers, as they will + // be applied to separate copies of the input. This may be relaxed in the + // future. + string apply_label_transformer = 19; + } +} + +// Specifies a particular change to be made to the contents of a row. +message Mutation { + // A Mutation which sets the value of the specified cell. + message SetCell { + // The name of the family into which new data should be written. + // Must match [-_.a-zA-Z0-9]+ + string family_name = 1; + + // The qualifier of the column into which new data should be written. + // Can be any byte string, including the empty string. + bytes column_qualifier = 2; + + // The timestamp of the cell into which new data should be written. + // Use -1 for current Bigtable server time. + // Otherwise, the client should set this value itself, noting that the + // default value is a timestamp of zero if the field is left unspecified. + // Values must match the "granularity" of the table (e.g. micros, millis). + int64 timestamp_micros = 3; + + // The value to be written into the specified cell. + bytes value = 4; + } + + // A Mutation which deletes cells from the specified column, optionally + // restricting the deletions to a given timestamp range. + message DeleteFromColumn { + // The name of the family from which cells should be deleted. + // Must match [-_.a-zA-Z0-9]+ + string family_name = 1; + + // The qualifier of the column from which cells should be deleted. + // Can be any byte string, including the empty string. + bytes column_qualifier = 2; + + // The range of timestamps within which cells should be deleted. + TimestampRange time_range = 3; + } + + // A Mutation which deletes all cells from the specified column family. + message DeleteFromFamily { + // The name of the family from which cells should be deleted. + // Must match [-_.a-zA-Z0-9]+ + string family_name = 1; + } + + // A Mutation which deletes all cells from the containing row. + message DeleteFromRow { + + } + + // Which of the possible Mutation types to apply. + oneof mutation { + // Set a cell's value. + SetCell set_cell = 1; + + // Deletes cells from a column. + DeleteFromColumn delete_from_column = 2; + + // Deletes cells from a column family. + DeleteFromFamily delete_from_family = 3; + + // Deletes cells from the entire row. + DeleteFromRow delete_from_row = 4; + } +} + +// Specifies an atomic read/modify/write operation on the latest value of the +// specified column. +message ReadModifyWriteRule { + // The name of the family to which the read/modify/write should be applied. + // Must match [-_.a-zA-Z0-9]+ + string family_name = 1; + + // The qualifier of the column to which the read/modify/write should be + // applied. + // Can be any byte string, including the empty string. + bytes column_qualifier = 2; + + // The rule used to determine the column's new latest value from its current + // latest value. + oneof rule { + // Rule specifying that "append_value" be appended to the existing value. + // If the targeted cell is unset, it will be treated as containing the + // empty string. + bytes append_value = 3; + + // Rule specifying that "increment_amount" be added to the existing value. + // If the targeted cell is unset, it will be treated as containing a zero. + // Otherwise, the targeted cell must contain an 8-byte value (interpreted + // as a 64-bit big-endian signed integer), or the entire request will fail. + int64 increment_amount = 4; + } +} diff --git a/gcloud/bigtable/_generated/_bigtable_service.proto b/gcloud/bigtable/_generated/_bigtable_service.proto new file mode 100755 index 000000000000..7f9109fdf34b --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_service.proto @@ -0,0 +1,66 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.v1; + +import "google/api/annotations.proto"; +import "google/bigtable/v1/bigtable_data.proto"; +import "google/bigtable/v1/bigtable_service_messages.proto"; +import "google/protobuf/empty.proto"; + +option java_generic_services = true; +option java_multiple_files = true; +option java_outer_classname = "BigtableServicesProto"; +option java_package = "com.google.bigtable.v1"; + + +// Service for reading from and writing to existing Bigtables. +service BigtableService { + // Streams back the contents of all requested rows, optionally applying + // the same Reader filter to each. Depending on their size, rows may be + // broken up across multiple responses, but atomicity of each row will still + // be preserved. + rpc ReadRows(ReadRowsRequest) returns (stream ReadRowsResponse) { + option (google.api.http) = { post: "/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows:read" body: "*" }; + } + + // Returns a sample of row keys in the table. The returned row keys will + // delimit contiguous sections of the table of approximately equal size, + // which can be used to break up the data for distributed tasks like + // mapreduces. + rpc SampleRowKeys(SampleRowKeysRequest) returns (stream SampleRowKeysResponse) { + option (google.api.http) = { get: "/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows:sampleKeys" }; + } + + // Mutates a row atomically. Cells already present in the row are left + // unchanged unless explicitly changed by 'mutation'. + rpc MutateRow(MutateRowRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { post: "/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows/{row_key}:mutate" body: "*" }; + } + + // Mutates a row atomically based on the output of a predicate Reader filter. + rpc CheckAndMutateRow(CheckAndMutateRowRequest) returns (CheckAndMutateRowResponse) { + option (google.api.http) = { post: "/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows/{row_key}:checkAndMutate" body: "*" }; + } + + // Modifies a row atomically, reading the latest existing timestamp/value from + // the specified columns and writing a new value at + // max(existing timestamp, current server time) based on pre-defined + // read/modify/write rules. Returns the new contents of all modified cells. + rpc ReadModifyWriteRow(ReadModifyWriteRowRequest) returns (Row) { + option (google.api.http) = { post: "/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows/{row_key}:readModifyWrite" body: "*" }; + } +} diff --git a/gcloud/bigtable/_generated/_bigtable_service_messages.proto b/gcloud/bigtable/_generated/_bigtable_service_messages.proto new file mode 100755 index 000000000000..dacc0fcad83d --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_service_messages.proto @@ -0,0 +1,177 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.v1; + +import "google/bigtable/v1/bigtable_data.proto"; + +option java_multiple_files = true; +option java_outer_classname = "BigtableServiceMessagesProto"; +option java_package = "com.google.bigtable.v1"; + + +// Request message for BigtableServer.ReadRows. +message ReadRowsRequest { + // The unique name of the table from which to read. + string table_name = 1; + + // If neither row_key nor row_range is set, reads from all rows. + oneof target { + // The key of a single row from which to read. + bytes row_key = 2; + + // A range of rows from which to read. + RowRange row_range = 3; + } + + // The filter to apply to the contents of the specified row(s). If unset, + // reads the entire table. + RowFilter filter = 5; + + // By default, rows are read sequentially, producing results which are + // guaranteed to arrive in increasing row order. Setting + // "allow_row_interleaving" to true allows multiple rows to be interleaved in + // the response stream, which increases throughput but breaks this guarantee, + // and may force the client to use more memory to buffer partially-received + // rows. Cannot be set to true when specifying "num_rows_limit". + bool allow_row_interleaving = 6; + + // The read will terminate after committing to N rows' worth of results. The + // default (zero) is to return all results. + // Note that "allow_row_interleaving" cannot be set to true when this is set. + int64 num_rows_limit = 7; +} + +// Response message for BigtableService.ReadRows. +message ReadRowsResponse { + // Specifies a piece of a row's contents returned as part of the read + // response stream. + message Chunk { + oneof chunk { + // A subset of the data from a particular row. As long as no "reset_row" + // is received in between, multiple "row_contents" from the same row are + // from the same atomic view of that row, and will be received in the + // expected family/column/timestamp order. + Family row_contents = 1; + + // Indicates that the client should drop all previous chunks for + // "row_key", as it will be re-read from the beginning. + bool reset_row = 2; + + // Indicates that the client can safely process all previous chunks for + // "row_key", as its data has been fully read. + bool commit_row = 3; + } + } + + // The key of the row for which we're receiving data. + // Results will be received in increasing row key order, unless + // "allow_row_interleaving" was specified in the request. + bytes row_key = 1; + + // One or more chunks of the row specified by "row_key". + repeated Chunk chunks = 2; +} + +// Request message for BigtableService.SampleRowKeys. +message SampleRowKeysRequest { + // The unique name of the table from which to sample row keys. + string table_name = 1; +} + +// Response message for BigtableService.SampleRowKeys. +message SampleRowKeysResponse { + // Sorted streamed sequence of sample row keys in the table. The table might + // have contents before the first row key in the list and after the last one, + // but a key containing the empty string indicates "end of table" and will be + // the last response given, if present. + // Note that row keys in this list may not have ever been written to or read + // from, and users should therefore not make any assumptions about the row key + // structure that are specific to their use case. + bytes row_key = 1; + + // Approximate total storage space used by all rows in the table which precede + // "row_key". Buffering the contents of all rows between two subsequent + // samples would require space roughly equal to the difference in their + // "offset_bytes" fields. + int64 offset_bytes = 2; +} + +// Request message for BigtableService.MutateRow. +message MutateRowRequest { + // The unique name of the table to which the mutation should be applied. + string table_name = 1; + + // The key of the row to which the mutation should be applied. + bytes row_key = 2; + + // Changes to be atomically applied to the specified row. Entries are applied + // in order, meaning that earlier mutations can be masked by later ones. + // Must contain at least one entry and at most 100000. + repeated Mutation mutations = 3; +} + +// Request message for BigtableService.CheckAndMutateRowRequest +message CheckAndMutateRowRequest { + // The unique name of the table to which the conditional mutation should be + // applied. + string table_name = 1; + + // The key of the row to which the conditional mutation should be applied. + bytes row_key = 2; + + // The filter to be applied to the contents of the specified row. Depending + // on whether or not any results are yielded, either "true_mutations" or + // "false_mutations" will be executed. If unset, checks that the row contains + // any values at all. + RowFilter predicate_filter = 6; + + // Changes to be atomically applied to the specified row if "predicate_filter" + // yields at least one cell when applied to "row_key". Entries are applied in + // order, meaning that earlier mutations can be masked by later ones. + // Must contain at least one entry if "false_mutations" is empty, and at most + // 100000. + repeated Mutation true_mutations = 4; + + // Changes to be atomically applied to the specified row if "predicate_filter" + // does not yield any cells when applied to "row_key". Entries are applied in + // order, meaning that earlier mutations can be masked by later ones. + // Must contain at least one entry if "true_mutations" is empty, and at most + // 100000. + repeated Mutation false_mutations = 5; +} + +// Response message for BigtableService.CheckAndMutateRowRequest. +message CheckAndMutateRowResponse { + // Whether or not the request's "predicate_filter" yielded any results for + // the specified row. + bool predicate_matched = 1; +} + +// Request message for BigtableService.ReadModifyWriteRowRequest. +message ReadModifyWriteRowRequest { + // The unique name of the table to which the read/modify/write rules should be + // applied. + string table_name = 1; + + // The key of the row to which the read/modify/write rules should be applied. + bytes row_key = 2; + + // Rules specifying how the specified row's contents are to be transformed + // into writes. Entries are applied in order, meaning that earlier rules will + // affect the results of later ones. + repeated ReadModifyWriteRule rules = 3; +} diff --git a/gcloud/bigtable/_generated/_bigtable_table_data.proto b/gcloud/bigtable/_generated/_bigtable_table_data.proto new file mode 100755 index 000000000000..f81c878f03b5 --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_table_data.proto @@ -0,0 +1,125 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.admin.table.v1; + +import "google/longrunning/operations.proto"; +import "google/protobuf/duration.proto"; + +option java_multiple_files = true; +option java_outer_classname = "BigtableTableDataProto"; +option java_package = "com.google.bigtable.admin.table.v1"; + + +// A collection of user data indexed by row, column, and timestamp. +// Each table is served using the resources of its parent cluster. +message Table { + enum TimestampGranularity { + MILLIS = 0; + } + + // A unique identifier of the form + // /tables/[_a-zA-Z0-9][-_.a-zA-Z0-9]* + string name = 1; + + // If this Table is in the process of being created, the Operation used to + // track its progress. As long as this operation is present, the Table will + // not accept any Table Admin or Read/Write requests. + google.longrunning.Operation current_operation = 2; + + // The column families configured for this table, mapped by column family id. + map column_families = 3; + + // The granularity (e.g. MILLIS, MICROS) at which timestamps are stored in + // this table. Timestamps not matching the granularity will be rejected. + // Cannot be changed once the table is created. + TimestampGranularity granularity = 4; +} + +// A set of columns within a table which share a common configuration. +message ColumnFamily { + // A unique identifier of the form /columnFamilies/[-_.a-zA-Z0-9]+ + // The last segment is the same as the "name" field in + // google.bigtable.v1.Family. + string name = 1; + + // Garbage collection expression specified by the following grammar: + // GC = EXPR + // | "" ; + // EXPR = EXPR, "||", EXPR (* lowest precedence *) + // | EXPR, "&&", EXPR + // | "(", EXPR, ")" (* highest precedence *) + // | PROP ; + // PROP = "version() >", NUM32 + // | "age() >", NUM64, [ UNIT ] ; + // NUM32 = non-zero-digit { digit } ; (* # NUM32 <= 2^32 - 1 *) + // NUM64 = non-zero-digit { digit } ; (* # NUM64 <= 2^63 - 1 *) + // UNIT = "d" | "h" | "m" (* d=days, h=hours, m=minutes, else micros *) + // GC expressions can be up to 500 characters in length + // + // The different types of PROP are defined as follows: + // version() - cell index, counting from most recent and starting at 1 + // age() - age of the cell (current time minus cell timestamp) + // + // Example: "version() > 3 || (age() > 3d && version() > 1)" + // drop cells beyond the most recent three, and drop cells older than three + // days unless they're the most recent cell in the row/column + // + // Garbage collection executes opportunistically in the background, and so + // it's possible for reads to return a cell even if it matches the active GC + // expression for its family. + string gc_expression = 2; + + // Garbage collection rule specified as a protobuf. + // Supersedes `gc_expression`. + // Must serialize to at most 500 bytes. + // + // NOTE: Garbage collection executes opportunistically in the background, and + // so it's possible for reads to return a cell even if it matches the active + // GC expression for its family. + GcRule gc_rule = 3; +} + +// Rule for determining which cells to delete during garbage collection. +message GcRule { + // A GcRule which deletes cells matching all of the given rules. + message Intersection { + // Only delete cells which would be deleted by every element of `rules`. + repeated GcRule rules = 1; + } + + // A GcRule which deletes cells matching any of the given rules. + message Union { + // Delete cells which would be deleted by any element of `rules`. + repeated GcRule rules = 1; + } + + oneof rule { + // Delete all cells in a column except the most recent N. + int32 max_num_versions = 1; + + // Delete cells in a column older than the given age. + // Values must be at least one millisecond, and will be truncated to + // microsecond granularity. + google.protobuf.Duration max_age = 2; + + // Delete cells that would be deleted by every nested rule. + Intersection intersection = 3; + + // Delete cells that would be deleted by any nested rule. + Union union = 4; + } +} diff --git a/gcloud/bigtable/_generated/_bigtable_table_service.proto b/gcloud/bigtable/_generated/_bigtable_table_service.proto new file mode 100755 index 000000000000..417409c4093b --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_table_service.proto @@ -0,0 +1,74 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.admin.table.v1; + +import "google/api/annotations.proto"; +import "google/bigtable/admin/table/v1/bigtable_table_data.proto"; +import "google/bigtable/admin/table/v1/bigtable_table_service_messages.proto"; +import "google/protobuf/empty.proto"; + +option java_multiple_files = true; +option java_outer_classname = "BigtableTableServicesProto"; +option java_package = "com.google.bigtable.admin.table.v1"; + + +// Service for creating, configuring, and deleting Cloud Bigtable tables. +// Provides access to the table schemas only, not the data stored within the tables. +service BigtableTableService { + // Creates a new table, to be served from a specified cluster. + // The table can be created with a full set of initial column families, + // specified in the request. + rpc CreateTable(CreateTableRequest) returns (Table) { + option (google.api.http) = { post: "/v1/{name=projects/*/zones/*/clusters/*}/tables" body: "*" }; + } + + // Lists the names of all tables served from a specified cluster. + rpc ListTables(ListTablesRequest) returns (ListTablesResponse) { + option (google.api.http) = { get: "/v1/{name=projects/*/zones/*/clusters/*}/tables" }; + } + + // Gets the schema of the specified table, including its column families. + rpc GetTable(GetTableRequest) returns (Table) { + option (google.api.http) = { get: "/v1/{name=projects/*/zones/*/clusters/*/tables/*}" }; + } + + // Permanently deletes a specified table and all of its data. + rpc DeleteTable(DeleteTableRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { delete: "/v1/{name=projects/*/zones/*/clusters/*/tables/*}" }; + } + + // Changes the name of a specified table. + // Cannot be used to move tables between clusters, zones, or projects. + rpc RenameTable(RenameTableRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { post: "/v1/{name=projects/*/zones/*/clusters/*/tables/*}:rename" body: "*" }; + } + + // Creates a new column family within a specified table. + rpc CreateColumnFamily(CreateColumnFamilyRequest) returns (ColumnFamily) { + option (google.api.http) = { post: "/v1/{name=projects/*/zones/*/clusters/*/tables/*}/columnFamilies" body: "*" }; + } + + // Changes the configuration of a specified column family. + rpc UpdateColumnFamily(ColumnFamily) returns (ColumnFamily) { + option (google.api.http) = { put: "/v1/{name=projects/*/zones/*/clusters/*/tables/*/columnFamilies/*}" body: "*" }; + } + + // Permanently deletes a specified column family and all of its data. + rpc DeleteColumnFamily(DeleteColumnFamilyRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { delete: "/v1/{name=projects/*/zones/*/clusters/*/tables/*/columnFamilies/*}" }; + } +} diff --git a/gcloud/bigtable/_generated/_bigtable_table_service_messages.proto b/gcloud/bigtable/_generated/_bigtable_table_service_messages.proto new file mode 100755 index 000000000000..73f2a8cfbf2b --- /dev/null +++ b/gcloud/bigtable/_generated/_bigtable_table_service_messages.proto @@ -0,0 +1,101 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.bigtable.admin.table.v1; + +import "google/bigtable/admin/table/v1/bigtable_table_data.proto"; + +option java_multiple_files = true; +option java_outer_classname = "BigtableTableServiceMessagesProto"; +option java_package = "com.google.bigtable.admin.table.v1"; + + +message CreateTableRequest { + // The unique name of the cluster in which to create the new table. + string name = 1; + + // The name by which the new table should be referred to within the cluster, + // e.g. "foobar" rather than "/tables/foobar". + string table_id = 2; + + // The Table to create. The `name` field of the Table and all of its + // ColumnFamilies must be left blank, and will be populated in the response. + Table table = 3; + + // The optional list of row keys that will be used to initially split the + // table into several tablets (Tablets are similar to HBase regions). + // Given two split keys, "s1" and "s2", three tablets will be created, + // spanning the key ranges: [, s1), [s1, s2), [s2, ). + // + // Example: + // * Row keys := ["a", "apple", "custom", "customer_1", "customer_2", + // "other", "zz"] + // * initial_split_keys := ["apple", "customer_1", "customer_2", "other"] + // * Key assignment: + // - Tablet 1 [, apple) => {"a"}. + // - Tablet 2 [apple, customer_1) => {"apple", "custom"}. + // - Tablet 3 [customer_1, customer_2) => {"customer_1"}. + // - Tablet 4 [customer_2, other) => {"customer_2"}. + // - Tablet 5 [other, ) => {"other", "zz"}. + repeated string initial_split_keys = 4; +} + +message ListTablesRequest { + // The unique name of the cluster for which tables should be listed. + string name = 1; +} + +message ListTablesResponse { + // The tables present in the requested cluster. + // At present, only the names of the tables are populated. + repeated Table tables = 1; +} + +message GetTableRequest { + // The unique name of the requested table. + string name = 1; +} + +message DeleteTableRequest { + // The unique name of the table to be deleted. + string name = 1; +} + +message RenameTableRequest { + // The current unique name of the table. + string name = 1; + + // The new name by which the table should be referred to within its containing + // cluster, e.g. "foobar" rather than "/tables/foobar". + string new_id = 2; +} + +message CreateColumnFamilyRequest { + // The unique name of the table in which to create the new column family. + string name = 1; + + // The name by which the new column family should be referred to within the + // table, e.g. "foobar" rather than "/columnFamilies/foobar". + string column_family_id = 2; + + // The column family to create. The `name` field must be left blank. + ColumnFamily column_family = 3; +} + +message DeleteColumnFamilyRequest { + // The unique name of the column family to be deleted. + string name = 1; +} diff --git a/gcloud/bigtable/_generated/_duration.proto b/gcloud/bigtable/_generated/_duration.proto new file mode 100755 index 000000000000..15e9d44d3b38 --- /dev/null +++ b/gcloud/bigtable/_generated/_duration.proto @@ -0,0 +1,78 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.protobuf; + +option java_generate_equals_and_hash = true; +option java_multiple_files = true; +option java_outer_classname = "DurationProto"; +option java_package = "com.google.protobuf"; + + +// A Duration represents a signed, fixed-length span of time represented +// as a count of seconds and fractions of seconds at nanosecond +// resolution. It is independent of any calendar and concepts like "day" +// or "month". It is related to Timestamp in that the difference between +// two Timestamp values is a Duration and it can be added or subtracted +// from a Timestamp. Range is approximately +-10,000 years. +// +// Example 1: Compute Duration from two Timestamps in pseudo code. +// +// Timestamp start = ...; +// Timestamp end = ...; +// Duration duration = ...; +// +// duration.seconds = end.seconds - start.seconds; +// duration.nanos = end.nanos - start.nanos; +// +// if (duration.seconds < 0 && duration.nanos > 0) { +// duration.seconds += 1; +// duration.nanos -= 1000000000; +// } else if (durations.seconds > 0 && duration.nanos < 0) { +// duration.seconds -= 1; +// duration.nanos += 1000000000; +// } +// +// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code. +// +// Timestamp start = ...; +// Duration duration = ...; +// Timestamp end = ...; +// +// end.seconds = start.seconds + duration.seconds; +// end.nanos = start.nanos + duration.nanos; +// +// if (end.nanos < 0) { +// end.seconds -= 1; +// end.nanos += 1000000000; +// } else if (end.nanos >= 1000000000) { +// end.seconds += 1; +// end.nanos -= 1000000000; +// } +// +message Duration { + // Signed seconds of the span of time. Must be from -315,576,000,000 + // to +315,576,000,000 inclusive. + int64 seconds = 1; + + // Signed fractions of a second at nanosecond resolution of the span + // of time. Durations less than one second are represented with a 0 + // `seconds` field and a positive or negative `nanos` field. For durations + // of one second or more, a non-zero value for the `nanos` field must be + // of the same sign as the `seconds` field. Must be from -999,999,999 + // to +999,999,999 inclusive. + int32 nanos = 2; +} diff --git a/gcloud/bigtable/_generated/_empty.proto b/gcloud/bigtable/_generated/_empty.proto new file mode 100755 index 000000000000..43b06e87bd68 --- /dev/null +++ b/gcloud/bigtable/_generated/_empty.proto @@ -0,0 +1,34 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.protobuf; + +option java_multiple_files = true; +option java_outer_classname = "EmptyProto"; +option java_package = "com.google.protobuf"; + + +// 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); +// } +// +message Empty { + +} diff --git a/gcloud/bigtable/_generated/_http.proto b/gcloud/bigtable/_generated/_http.proto new file mode 100755 index 000000000000..ce07aa14f54f --- /dev/null +++ b/gcloud/bigtable/_generated/_http.proto @@ -0,0 +1,127 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.api; + +option java_multiple_files = true; +option java_outer_classname = "HttpProto"; +option java_package = "com.google.api"; + + +// `HttpRule` defines the mapping of an RPC method to one or more HTTP REST API +// methods. The mapping determines what portions of the request message are +// populated from the path, query parameters, or body of the HTTP request. The +// mapping is typically specified as an `google.api.http` annotation, see +// "google/api/annotations.proto" for details. +// +// The mapping consists of a mandatory field specifying a path template and an +// optional `body` field specifying what data is represented in the HTTP request +// body. The field name for the path indicates the HTTP method. Example: +// +// ``` +// package google.storage.v2; +// +// import "google/api/annotations.proto"; +// +// service Storage { +// rpc CreateObject(CreateObjectRequest) returns (Object) { +// option (google.api.http) { +// post: "/v2/{bucket_name=buckets/*}/objects" +// body: "object" +// }; +// }; +// } +// ``` +// +// Here `bucket_name` and `object` bind to fields of the request message +// `CreateObjectRequest`. +// +// The rules for mapping HTTP path, query parameters, and body fields +// to the request message are as follows: +// +// 1. The `body` field specifies either `*` or a field path, or is +// omitted. If omitted, it assumes there is no HTTP body. +// 2. Leaf fields (recursive expansion of nested messages in the +// request) can be classified into three types: +// (a) Matched in the URL template. +// (b) Covered by body (if body is `*`, everything except (a) fields; +// else everything under the body field) +// (c) All other fields. +// 3. URL query parameters found in the HTTP request are mapped to (c) fields. +// 4. Any body sent with an HTTP request can contain only (b) fields. +// +// The syntax of the path template is as follows: +// +// Template = "/" Segments [ Verb ] ; +// Segments = Segment { "/" Segment } ; +// Segment = "*" | "**" | LITERAL | Variable ; +// Variable = "{" FieldPath [ "=" Segments ] "}" ; +// FieldPath = IDENT { "." IDENT } ; +// Verb = ":" LITERAL ; +// +// `*` matches a single path component, `**` zero or more path components, and +// `LITERAL` a constant. A `Variable` can match an entire path as specified +// again by a template; this nested template must not contain further variables. +// If no template is given with a variable, it matches a single path component. +// The notation `{var}` is henceforth equivalent to `{var=*}`. +// +// Use CustomHttpPattern to specify any HTTP method that is not included in the +// pattern field, such as HEAD, or "*" to leave the HTTP method unspecified for +// a given URL path rule. The wild-card rule is useful for services that provide +// content to Web (HTML) clients. +message HttpRule { + + // Determines the URL pattern is matched by this rules. This pattern can be + // used with any of the {get|put|post|delete|patch} methods. A custom method + // can be defined using the 'custom' field. + oneof pattern { + // Used for listing and getting information about resources. + string get = 2; + + // Used for updating a resource. + string put = 3; + + // Used for creating a resource. + string post = 4; + + // Used for deleting a resource. + string delete = 5; + + // Used for updating a resource. + string patch = 6; + + // Custom pattern is used for defining custom verbs. + CustomHttpPattern custom = 8; + } + + // The name of the request field whose value is mapped to the HTTP body, or + // `*` for mapping all fields not captured by the path pattern to the HTTP + // body. + string body = 7; + + // Additional HTTP bindings for the selector. Nested bindings must not + // specify a selector and must not contain additional bindings. + repeated HttpRule additional_bindings = 11; +} + +// A custom pattern is used for defining custom HTTP verb. +message CustomHttpPattern { + // The name of this custom HTTP verb. + string kind = 1; + + // The path matched by this custom verb. + string path = 2; +} diff --git a/gcloud/bigtable/_generated/_operations.proto b/gcloud/bigtable/_generated/_operations.proto new file mode 100755 index 000000000000..a358d0a38787 --- /dev/null +++ b/gcloud/bigtable/_generated/_operations.proto @@ -0,0 +1,144 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.longrunning; + +import "google/api/annotations.proto"; +import "google/protobuf/any.proto"; +import "google/protobuf/empty.proto"; +import "google/rpc/status.proto"; + +option java_multiple_files = true; +option java_outer_classname = "OperationsProto"; +option java_package = "com.google.longrunning"; + + +// Manages long-running operations with an API service. +// +// When an API method normally takes long time to complete, it can be designed +// to return [Operation][google.longrunning.Operation] to the client, and the client can use this +// interface to receive the real response asynchronously by polling the +// operation resource, or using `google.watcher.v1.Watcher` interface to watch +// the response, or pass the operation resource to another API (such as Google +// Cloud Pub/Sub API) to receive the response. Any API service that returns +// long-running operations should implement the `Operations` interface so +// developers can have a consistent client experience. +service Operations { + // Gets the latest state of a long-running operation. Clients may use this + // method to poll the operation result at intervals as recommended by the API + // service. + rpc GetOperation(GetOperationRequest) returns (Operation) { + option (google.api.http) = { get: "/v1/{name=operations/**}" }; + } + + // Lists operations that match the specified filter in the request. If the + // server doesn't support this method, it returns + // `google.rpc.Code.UNIMPLEMENTED`. + rpc ListOperations(ListOperationsRequest) returns (ListOperationsResponse) { + option (google.api.http) = { get: "/v1/{name=operations}" }; + } + + // Starts asynchronous cancellation on a long-running operation. The server + // makes a best effort to cancel the operation, but success is not + // guaranteed. If the server doesn't support this method, it returns + // `google.rpc.Code.UNIMPLEMENTED`. Clients may use + // [Operations.GetOperation] or other methods to check whether the + // cancellation succeeded or the operation completed despite cancellation. + rpc CancelOperation(CancelOperationRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { post: "/v1/{name=operations/**}:cancel" body: "*" }; + } + + // Deletes a long-running operation. It indicates the client is no longer + // interested in the operation result. It does not cancel the operation. + rpc DeleteOperation(DeleteOperationRequest) returns (google.protobuf.Empty) { + option (google.api.http) = { delete: "/v1/{name=operations/**}" }; + } +} + +// This resource represents a long-running operation that is the result of a +// network API call. +message Operation { + // The name of the operation resource, which is only unique within the same + // service that originally returns it. + string name = 1; + + // Some service-specific metadata associated with the operation. It typically + // contains progress information and common metadata such as create time. + // Some services may not provide such metadata. Any method that returns a + // long-running operation should document the metadata type, if any. + google.protobuf.Any metadata = 2; + + // If the value is false, it means the operation is still in progress. + // If true, the operation is completed and the `result` is available. + bool done = 3; + + oneof result { + // The error result of the operation in case of failure. + google.rpc.Status error = 4; + + // The normal response of the operation in case of success. If the original + // method returns no data on success, such as `Delete`, the response will be + // `google.protobuf.Empty`. If the original method is standard + // `Get`/`Create`/`Update`, the response should be the resource. For other + // methods, the response should have the type `XxxResponse`, where `Xxx` + // is the original method name. For example, if the original method name + // is `TakeSnapshot()`, the inferred response type will be + // `TakeSnapshotResponse`. + google.protobuf.Any response = 5; + } +} + +// The request message for [Operations.GetOperation][google.longrunning.Operations.GetOperation]. +message GetOperationRequest { + // The name of the operation resource. + string name = 1; +} + +// The request message for [Operations.ListOperations][google.longrunning.Operations.ListOperations]. +message ListOperationsRequest { + // The name of the operation collection. + string name = 4; + + // The standard List filter. + string filter = 1; + + // The standard List page size. + int32 page_size = 2; + + // The standard List page token. + string page_token = 3; +} + +// The response message for [Operations.ListOperations][google.longrunning.Operations.ListOperations]. +message ListOperationsResponse { + // A list of operations that match the specified filter in the request. + repeated Operation operations = 1; + + // The standard List next-page token. + string next_page_token = 2; +} + +// The request message for [Operations.CancelOperation][google.longrunning.Operations.CancelOperation]. +message CancelOperationRequest { + // The name of the operation resource to be cancelled. + string name = 1; +} + +// The request message for [Operations.DeleteOperation][google.longrunning.Operations.DeleteOperation]. +message DeleteOperationRequest { + // The name of the operation resource to be deleted. + string name = 1; +} diff --git a/gcloud/bigtable/_generated/_status.proto b/gcloud/bigtable/_generated/_status.proto new file mode 100755 index 000000000000..be97fa4eaeff --- /dev/null +++ b/gcloud/bigtable/_generated/_status.proto @@ -0,0 +1,88 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.rpc; + +import "google/protobuf/any.proto"; + +option java_multiple_files = true; +option java_outer_classname = "StatusProto"; +option java_package = "com.google.rpc"; + + +// The `Status` 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 3 pieces of data: error code, error message, +// and error details. The error code should be an enum value of +// [google.rpc.Code][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, it can be sent in the error details or localized by +// 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 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. +// +message Status { + // The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code]. + int32 code = 1; + + // 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][google.rpc.Status.details] field, or localized by the client. + string message = 2; + + // A list of messages that carry the error details. There will be a + // common set of message types for APIs to use. + repeated google.protobuf.Any details = 3; +} diff --git a/gcloud/bigtable/_generated/_timestamp.proto b/gcloud/bigtable/_generated/_timestamp.proto new file mode 100755 index 000000000000..b13585498795 --- /dev/null +++ b/gcloud/bigtable/_generated/_timestamp.proto @@ -0,0 +1,89 @@ +// Copyright (c) 2015, Google Inc. +// +// 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 +// +// http://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. + +syntax = "proto3"; + +package google.protobuf; + +option java_generate_equals_and_hash = true; +option java_multiple_files = true; +option java_outer_classname = "TimestampProto"; +option java_package = "com.google.protobuf"; + + +// A Timestamp represents a point in time independent of any time zone +// or calendar, represented as seconds and fractions of seconds at +// nanosecond resolution in UTC Epoch time. It is encoded using the +// Proleptic Gregorian Calendar which extends the Gregorian calendar +// backwards to year one. It is encoded assuming all minutes are 60 +// seconds long, i.e. leap seconds are "smeared" so that no leap second +// table is needed for interpretation. Range is from +// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. +// By restricting to that range, we ensure that we can convert to +// and from RFC 3339 date strings. +// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt). +// +// Example 1: Compute Timestamp from POSIX `time()`. +// +// Timestamp timestamp; +// timestamp.set_seconds(time(NULL)); +// timestamp.set_nanos(0); +// +// Example 2: Compute Timestamp from POSIX `gettimeofday()`. +// +// struct timeval tv; +// gettimeofday(&tv, NULL); +// +// Timestamp timestamp; +// timestamp.set_seconds(tv.tv_sec); +// timestamp.set_nanos(tv.tv_usec * 1000); +// +// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`. +// +// FILETIME ft; +// GetSystemTimeAsFileTime(&ft); +// UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime; +// +// // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z +// // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z. +// Timestamp timestamp; +// timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL)); +// timestamp.set_nanos((INT32) ((ticks % 10000000) * 100)); +// +// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`. +// +// long millis = System.currentTimeMillis(); +// +// Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000) +// .setNanos((int) ((millis % 1000) * 1000000)).build(); +// +// Example 5: Compute Timestamp from Python `datetime.datetime`. +// +// now = datetime.datetime.utcnow() +// seconds = int(time.mktime(now.timetuple())) +// nanos = now.microsecond * 1000 +// timestamp = Timestamp(seconds=seconds, nanos=nanos) +// +message Timestamp { + // Represents seconds of UTC time since Unix epoch + // 1970-01-01T00:00:00Z. Must be from from 0001-01-01T00:00:00Z to + // 9999-12-31T23:59:59Z inclusive. + int64 seconds = 1; + + // Non-negative fractions of a second at nanosecond resolution. Negative + // second values with fractions must still have non-negative nanos values + // that count forward in time. Must be from 0 to 999,999,999 + // inclusive. + int32 nanos = 2; +} diff --git a/gcloud/bigtable/_generated/annotations_pb2.py b/gcloud/bigtable/_generated/annotations_pb2.py new file mode 100644 index 000000000000..1640068118f9 --- /dev/null +++ b/gcloud/bigtable/_generated/annotations_pb2.py @@ -0,0 +1,49 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/api/annotations.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import http_pb2 as google_dot_api_dot_http__pb2 +from google.protobuf import descriptor_pb2 as google_dot_protobuf_dot_descriptor__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/api/annotations.proto', + package='google.api', + syntax='proto3', + serialized_pb=_b('\n\x1cgoogle/api/annotations.proto\x12\ngoogle.api\x1a\x15google/api/http.proto\x1a google/protobuf/descriptor.proto:E\n\x04http\x12\x1e.google.protobuf.MethodOptions\x18\xb0\xca\xbc\" \x01(\x0b\x32\x14.google.api.HttpRuleB$\n\x0e\x63om.google.apiB\x10\x41nnotationsProtoP\x01\x62\x06proto3') + , + dependencies=[google_dot_api_dot_http__pb2.DESCRIPTOR,google_dot_protobuf_dot_descriptor__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + +HTTP_FIELD_NUMBER = 72295728 +http = _descriptor.FieldDescriptor( + name='http', full_name='google.api.http', index=0, + number=72295728, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=True, extension_scope=None, + options=None) + +DESCRIPTOR.extensions_by_name['http'] = http + +http.message_type = google_dot_api_dot_http__pb2._HTTPRULE +google_dot_protobuf_dot_descriptor__pb2.MethodOptions.RegisterExtension(http) + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\016com.google.apiB\020AnnotationsProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/any_pb2.py b/gcloud/bigtable/_generated/any_pb2.py new file mode 100644 index 000000000000..4c31a1588d43 --- /dev/null +++ b/gcloud/bigtable/_generated/any_pb2.py @@ -0,0 +1,81 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/protobuf/any.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/protobuf/any.proto', + package='google.protobuf', + syntax='proto3', + serialized_pb=_b('\n\x19google/protobuf/any.proto\x12\x0fgoogle.protobuf\"&\n\x03\x41ny\x12\x10\n\x08type_url\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c\x42$\n\x13\x63om.google.protobufB\x08\x41nyProtoP\x01\xa0\x01\x01\x62\x06proto3') +) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_ANY = _descriptor.Descriptor( + name='Any', + full_name='google.protobuf.Any', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='type_url', full_name='google.protobuf.Any.type_url', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='google.protobuf.Any.value', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=46, + serialized_end=84, +) + +DESCRIPTOR.message_types_by_name['Any'] = _ANY + +Any = _reflection.GeneratedProtocolMessageType('Any', (_message.Message,), dict( + DESCRIPTOR = _ANY, + __module__ = 'google.protobuf.any_pb2' + # @@protoc_insertion_point(class_scope:google.protobuf.Any) + )) +_sym_db.RegisterMessage(Any) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\023com.google.protobufB\010AnyProtoP\001\240\001\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/bigtable_cluster_data_pb2.py b/gcloud/bigtable/_generated/bigtable_cluster_data_pb2.py new file mode 100644 index 000000000000..5c1543877d2a --- /dev/null +++ b/gcloud/bigtable/_generated/bigtable_cluster_data_pb2.py @@ -0,0 +1,229 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/bigtable/admin/cluster/v1/bigtable_cluster_data.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf.internal import enum_type_wrapper +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from gcloud.bigtable._generated import operations_pb2 as google_dot_longrunning_dot_operations__pb2 +from gcloud.bigtable._generated import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/bigtable/admin/cluster/v1/bigtable_cluster_data.proto', + package='google.bigtable.admin.cluster.v1', + syntax='proto3', + serialized_pb=_b('\n""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def ListZones(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def GetCluster(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def ListClusters(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def CreateCluster(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def UpdateCluster(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def DeleteCluster(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def UndeleteCluster(self, request, context): + raise NotImplementedError() +class EarlyAdopterBigtableClusterServiceServer(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def start(self): + raise NotImplementedError() + @abc.abstractmethod + def stop(self): + raise NotImplementedError() +class EarlyAdopterBigtableClusterServiceStub(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def ListZones(self, request): + raise NotImplementedError() + ListZones.async = None + @abc.abstractmethod + def GetCluster(self, request): + raise NotImplementedError() + GetCluster.async = None + @abc.abstractmethod + def ListClusters(self, request): + raise NotImplementedError() + ListClusters.async = None + @abc.abstractmethod + def CreateCluster(self, request): + raise NotImplementedError() + CreateCluster.async = None + @abc.abstractmethod + def UpdateCluster(self, request): + raise NotImplementedError() + UpdateCluster.async = None + @abc.abstractmethod + def DeleteCluster(self, request): + raise NotImplementedError() + DeleteCluster.async = None + @abc.abstractmethod + def UndeleteCluster(self, request): + raise NotImplementedError() + UndeleteCluster.async = None +def early_adopter_create_BigtableClusterService_server(servicer, port, private_key=None, certificate_chain=None): + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_data_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_data_pb2 + import gcloud.bigtable._generated.bigtable_cluster_data_pb2 + import gcloud.bigtable._generated.bigtable_cluster_data_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.operations_pb2 + method_service_descriptions = { + "CreateCluster": utilities.unary_unary_service_description( + servicer.CreateCluster, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.CreateClusterRequest.FromString, + gcloud.bigtable._generated.bigtable_cluster_data_pb2.Cluster.SerializeToString, + ), + "DeleteCluster": utilities.unary_unary_service_description( + servicer.DeleteCluster, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.DeleteClusterRequest.FromString, + gcloud.bigtable._generated.empty_pb2.Empty.SerializeToString, + ), + "GetCluster": utilities.unary_unary_service_description( + servicer.GetCluster, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.GetClusterRequest.FromString, + gcloud.bigtable._generated.bigtable_cluster_data_pb2.Cluster.SerializeToString, + ), + "ListClusters": utilities.unary_unary_service_description( + servicer.ListClusters, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.ListClustersRequest.FromString, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.ListClustersResponse.SerializeToString, + ), + "ListZones": utilities.unary_unary_service_description( + servicer.ListZones, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.ListZonesRequest.FromString, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.ListZonesResponse.SerializeToString, + ), + "UndeleteCluster": utilities.unary_unary_service_description( + servicer.UndeleteCluster, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.UndeleteClusterRequest.FromString, + gcloud.bigtable._generated.operations_pb2.Operation.SerializeToString, + ), + "UpdateCluster": utilities.unary_unary_service_description( + servicer.UpdateCluster, + gcloud.bigtable._generated.bigtable_cluster_data_pb2.Cluster.FromString, + gcloud.bigtable._generated.bigtable_cluster_data_pb2.Cluster.SerializeToString, + ), + } + return implementations.server("google.bigtable.admin.cluster.v1.BigtableClusterService", method_service_descriptions, port, private_key=private_key, certificate_chain=certificate_chain) +def early_adopter_create_BigtableClusterService_stub(host, port, metadata_transformer=None, secure=False, root_certificates=None, private_key=None, certificate_chain=None, server_host_override=None): + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_data_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_cluster_data_pb2 + import gcloud.bigtable._generated.bigtable_cluster_data_pb2 + import gcloud.bigtable._generated.bigtable_cluster_data_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2 + import gcloud.bigtable._generated.operations_pb2 + method_invocation_descriptions = { + "CreateCluster": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.CreateClusterRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_cluster_data_pb2.Cluster.FromString, + ), + "DeleteCluster": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.DeleteClusterRequest.SerializeToString, + gcloud.bigtable._generated.empty_pb2.Empty.FromString, + ), + "GetCluster": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.GetClusterRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_cluster_data_pb2.Cluster.FromString, + ), + "ListClusters": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.ListClustersRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.ListClustersResponse.FromString, + ), + "ListZones": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.ListZonesRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.ListZonesResponse.FromString, + ), + "UndeleteCluster": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_cluster_service_messages_pb2.UndeleteClusterRequest.SerializeToString, + gcloud.bigtable._generated.operations_pb2.Operation.FromString, + ), + "UpdateCluster": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_cluster_data_pb2.Cluster.SerializeToString, + gcloud.bigtable._generated.bigtable_cluster_data_pb2.Cluster.FromString, + ), + } + return implementations.stub("google.bigtable.admin.cluster.v1.BigtableClusterService", method_invocation_descriptions, host, port, metadata_transformer=metadata_transformer, secure=secure, root_certificates=root_certificates, private_key=private_key, certificate_chain=certificate_chain, server_host_override=server_host_override) +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/bigtable_data_pb2.py b/gcloud/bigtable/_generated/bigtable_data_pb2.py new file mode 100644 index 000000000000..cb8f0b1dd73a --- /dev/null +++ b/gcloud/bigtable/_generated/bigtable_data_pb2.py @@ -0,0 +1,1184 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/bigtable/v1/bigtable_data.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/bigtable/v1/bigtable_data.proto', + package='google.bigtable.v1', + syntax='proto3', + serialized_pb=_b('\n&google/bigtable/v1/bigtable_data.proto\x12\x12google.bigtable.v1\"@\n\x03Row\x12\x0b\n\x03key\x18\x01 \x01(\x0c\x12,\n\x08\x66\x61milies\x18\x02 \x03(\x0b\x32\x1a.google.bigtable.v1.Family\"C\n\x06\x46\x61mily\x12\x0c\n\x04name\x18\x01 \x01(\t\x12+\n\x07\x63olumns\x18\x02 \x03(\x0b\x32\x1a.google.bigtable.v1.Column\"D\n\x06\x43olumn\x12\x11\n\tqualifier\x18\x01 \x01(\x0c\x12\'\n\x05\x63\x65lls\x18\x02 \x03(\x0b\x32\x18.google.bigtable.v1.Cell\"?\n\x04\x43\x65ll\x12\x18\n\x10timestamp_micros\x18\x01 \x01(\x03\x12\r\n\x05value\x18\x02 \x01(\x0c\x12\x0e\n\x06labels\x18\x03 \x03(\t\".\n\x08RowRange\x12\x11\n\tstart_key\x18\x02 \x01(\x0c\x12\x0f\n\x07\x65nd_key\x18\x03 \x01(\x0c\"\xd6\x01\n\x0b\x43olumnRange\x12\x13\n\x0b\x66\x61mily_name\x18\x01 \x01(\t\x12#\n\x19start_qualifier_inclusive\x18\x02 \x01(\x0cH\x00\x12#\n\x19start_qualifier_exclusive\x18\x03 \x01(\x0cH\x00\x12!\n\x17\x65nd_qualifier_inclusive\x18\x04 \x01(\x0cH\x01\x12!\n\x17\x65nd_qualifier_exclusive\x18\x05 \x01(\x0cH\x01\x42\x11\n\x0fstart_qualifierB\x0f\n\rend_qualifier\"N\n\x0eTimestampRange\x12\x1e\n\x16start_timestamp_micros\x18\x01 \x01(\x03\x12\x1c\n\x14\x65nd_timestamp_micros\x18\x02 \x01(\x03\"\xa8\x01\n\nValueRange\x12\x1f\n\x15start_value_inclusive\x18\x01 \x01(\x0cH\x00\x12\x1f\n\x15start_value_exclusive\x18\x02 \x01(\x0cH\x00\x12\x1d\n\x13\x65nd_value_inclusive\x18\x03 \x01(\x0cH\x01\x12\x1d\n\x13\x65nd_value_exclusive\x18\x04 \x01(\x0cH\x01\x42\r\n\x0bstart_valueB\x0b\n\tend_value\"\xdf\x08\n\tRowFilter\x12\x34\n\x05\x63hain\x18\x01 \x01(\x0b\x32#.google.bigtable.v1.RowFilter.ChainH\x00\x12>\n\ninterleave\x18\x02 \x01(\x0b\x32(.google.bigtable.v1.RowFilter.InterleaveH\x00\x12<\n\tcondition\x18\x03 \x01(\x0b\x32\'.google.bigtable.v1.RowFilter.ConditionH\x00\x12\x0e\n\x04sink\x18\x10 \x01(\x08H\x00\x12\x19\n\x0fpass_all_filter\x18\x11 \x01(\x08H\x00\x12\x1a\n\x10\x62lock_all_filter\x18\x12 \x01(\x08H\x00\x12\x1e\n\x14row_key_regex_filter\x18\x04 \x01(\x0cH\x00\x12\x1b\n\x11row_sample_filter\x18\x0e \x01(\x01H\x00\x12\"\n\x18\x66\x61mily_name_regex_filter\x18\x05 \x01(\tH\x00\x12\'\n\x1d\x63olumn_qualifier_regex_filter\x18\x06 \x01(\x0cH\x00\x12>\n\x13\x63olumn_range_filter\x18\x07 \x01(\x0b\x32\x1f.google.bigtable.v1.ColumnRangeH\x00\x12\x44\n\x16timestamp_range_filter\x18\x08 \x01(\x0b\x32\".google.bigtable.v1.TimestampRangeH\x00\x12\x1c\n\x12value_regex_filter\x18\t \x01(\x0cH\x00\x12<\n\x12value_range_filter\x18\x0f \x01(\x0b\x32\x1e.google.bigtable.v1.ValueRangeH\x00\x12%\n\x1b\x63\x65lls_per_row_offset_filter\x18\n \x01(\x05H\x00\x12$\n\x1a\x63\x65lls_per_row_limit_filter\x18\x0b \x01(\x05H\x00\x12\'\n\x1d\x63\x65lls_per_column_limit_filter\x18\x0c \x01(\x05H\x00\x12!\n\x17strip_value_transformer\x18\r \x01(\x08H\x00\x12!\n\x17\x61pply_label_transformer\x18\x13 \x01(\tH\x00\x1a\x37\n\x05\x43hain\x12.\n\x07\x66ilters\x18\x01 \x03(\x0b\x32\x1d.google.bigtable.v1.RowFilter\x1a<\n\nInterleave\x12.\n\x07\x66ilters\x18\x01 \x03(\x0b\x32\x1d.google.bigtable.v1.RowFilter\x1a\xad\x01\n\tCondition\x12\x37\n\x10predicate_filter\x18\x01 \x01(\x0b\x32\x1d.google.bigtable.v1.RowFilter\x12\x32\n\x0btrue_filter\x18\x02 \x01(\x0b\x32\x1d.google.bigtable.v1.RowFilter\x12\x33\n\x0c\x66\x61lse_filter\x18\x03 \x01(\x0b\x32\x1d.google.bigtable.v1.RowFilterB\x08\n\x06\x66ilter\"\xc9\x04\n\x08Mutation\x12\x38\n\x08set_cell\x18\x01 \x01(\x0b\x32$.google.bigtable.v1.Mutation.SetCellH\x00\x12K\n\x12\x64\x65lete_from_column\x18\x02 \x01(\x0b\x32-.google.bigtable.v1.Mutation.DeleteFromColumnH\x00\x12K\n\x12\x64\x65lete_from_family\x18\x03 \x01(\x0b\x32-.google.bigtable.v1.Mutation.DeleteFromFamilyH\x00\x12\x45\n\x0f\x64\x65lete_from_row\x18\x04 \x01(\x0b\x32*.google.bigtable.v1.Mutation.DeleteFromRowH\x00\x1a\x61\n\x07SetCell\x12\x13\n\x0b\x66\x61mily_name\x18\x01 \x01(\t\x12\x18\n\x10\x63olumn_qualifier\x18\x02 \x01(\x0c\x12\x18\n\x10timestamp_micros\x18\x03 \x01(\x03\x12\r\n\x05value\x18\x04 \x01(\x0c\x1ay\n\x10\x44\x65leteFromColumn\x12\x13\n\x0b\x66\x61mily_name\x18\x01 \x01(\t\x12\x18\n\x10\x63olumn_qualifier\x18\x02 \x01(\x0c\x12\x36\n\ntime_range\x18\x03 \x01(\x0b\x32\".google.bigtable.v1.TimestampRange\x1a\'\n\x10\x44\x65leteFromFamily\x12\x13\n\x0b\x66\x61mily_name\x18\x01 \x01(\t\x1a\x0f\n\rDeleteFromRowB\n\n\x08mutation\"\x80\x01\n\x13ReadModifyWriteRule\x12\x13\n\x0b\x66\x61mily_name\x18\x01 \x01(\t\x12\x18\n\x10\x63olumn_qualifier\x18\x02 \x01(\x0c\x12\x16\n\x0c\x61ppend_value\x18\x03 \x01(\x0cH\x00\x12\x1a\n\x10increment_amount\x18\x04 \x01(\x03H\x00\x42\x06\n\x04ruleB-\n\x16\x63om.google.bigtable.v1B\x11\x42igtableDataProtoP\x01\x62\x06proto3') +) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_ROW = _descriptor.Descriptor( + name='Row', + full_name='google.bigtable.v1.Row', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='key', full_name='google.bigtable.v1.Row.key', index=0, + number=1, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='families', full_name='google.bigtable.v1.Row.families', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=62, + serialized_end=126, +) + + +_FAMILY = _descriptor.Descriptor( + name='Family', + full_name='google.bigtable.v1.Family', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.v1.Family.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='columns', full_name='google.bigtable.v1.Family.columns', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=128, + serialized_end=195, +) + + +_COLUMN = _descriptor.Descriptor( + name='Column', + full_name='google.bigtable.v1.Column', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='qualifier', full_name='google.bigtable.v1.Column.qualifier', index=0, + number=1, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='cells', full_name='google.bigtable.v1.Column.cells', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=197, + serialized_end=265, +) + + +_CELL = _descriptor.Descriptor( + name='Cell', + full_name='google.bigtable.v1.Cell', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='timestamp_micros', full_name='google.bigtable.v1.Cell.timestamp_micros', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='google.bigtable.v1.Cell.value', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='labels', full_name='google.bigtable.v1.Cell.labels', index=2, + number=3, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=267, + serialized_end=330, +) + + +_ROWRANGE = _descriptor.Descriptor( + name='RowRange', + full_name='google.bigtable.v1.RowRange', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='start_key', full_name='google.bigtable.v1.RowRange.start_key', index=0, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='end_key', full_name='google.bigtable.v1.RowRange.end_key', index=1, + number=3, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=332, + serialized_end=378, +) + + +_COLUMNRANGE = _descriptor.Descriptor( + name='ColumnRange', + full_name='google.bigtable.v1.ColumnRange', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='family_name', full_name='google.bigtable.v1.ColumnRange.family_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='start_qualifier_inclusive', full_name='google.bigtable.v1.ColumnRange.start_qualifier_inclusive', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='start_qualifier_exclusive', full_name='google.bigtable.v1.ColumnRange.start_qualifier_exclusive', index=2, + number=3, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='end_qualifier_inclusive', full_name='google.bigtable.v1.ColumnRange.end_qualifier_inclusive', index=3, + number=4, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='end_qualifier_exclusive', full_name='google.bigtable.v1.ColumnRange.end_qualifier_exclusive', index=4, + number=5, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='start_qualifier', full_name='google.bigtable.v1.ColumnRange.start_qualifier', + index=0, containing_type=None, fields=[]), + _descriptor.OneofDescriptor( + name='end_qualifier', full_name='google.bigtable.v1.ColumnRange.end_qualifier', + index=1, containing_type=None, fields=[]), + ], + serialized_start=381, + serialized_end=595, +) + + +_TIMESTAMPRANGE = _descriptor.Descriptor( + name='TimestampRange', + full_name='google.bigtable.v1.TimestampRange', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='start_timestamp_micros', full_name='google.bigtable.v1.TimestampRange.start_timestamp_micros', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='end_timestamp_micros', full_name='google.bigtable.v1.TimestampRange.end_timestamp_micros', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=597, + serialized_end=675, +) + + +_VALUERANGE = _descriptor.Descriptor( + name='ValueRange', + full_name='google.bigtable.v1.ValueRange', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='start_value_inclusive', full_name='google.bigtable.v1.ValueRange.start_value_inclusive', index=0, + number=1, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='start_value_exclusive', full_name='google.bigtable.v1.ValueRange.start_value_exclusive', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='end_value_inclusive', full_name='google.bigtable.v1.ValueRange.end_value_inclusive', index=2, + number=3, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='end_value_exclusive', full_name='google.bigtable.v1.ValueRange.end_value_exclusive', index=3, + number=4, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='start_value', full_name='google.bigtable.v1.ValueRange.start_value', + index=0, containing_type=None, fields=[]), + _descriptor.OneofDescriptor( + name='end_value', full_name='google.bigtable.v1.ValueRange.end_value', + index=1, containing_type=None, fields=[]), + ], + serialized_start=678, + serialized_end=846, +) + + +_ROWFILTER_CHAIN = _descriptor.Descriptor( + name='Chain', + full_name='google.bigtable.v1.RowFilter.Chain', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='filters', full_name='google.bigtable.v1.RowFilter.Chain.filters', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1665, + serialized_end=1720, +) + +_ROWFILTER_INTERLEAVE = _descriptor.Descriptor( + name='Interleave', + full_name='google.bigtable.v1.RowFilter.Interleave', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='filters', full_name='google.bigtable.v1.RowFilter.Interleave.filters', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1722, + serialized_end=1782, +) + +_ROWFILTER_CONDITION = _descriptor.Descriptor( + name='Condition', + full_name='google.bigtable.v1.RowFilter.Condition', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='predicate_filter', full_name='google.bigtable.v1.RowFilter.Condition.predicate_filter', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='true_filter', full_name='google.bigtable.v1.RowFilter.Condition.true_filter', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='false_filter', full_name='google.bigtable.v1.RowFilter.Condition.false_filter', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1785, + serialized_end=1958, +) + +_ROWFILTER = _descriptor.Descriptor( + name='RowFilter', + full_name='google.bigtable.v1.RowFilter', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='chain', full_name='google.bigtable.v1.RowFilter.chain', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='interleave', full_name='google.bigtable.v1.RowFilter.interleave', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='condition', full_name='google.bigtable.v1.RowFilter.condition', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='sink', full_name='google.bigtable.v1.RowFilter.sink', index=3, + number=16, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='pass_all_filter', full_name='google.bigtable.v1.RowFilter.pass_all_filter', index=4, + number=17, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='block_all_filter', full_name='google.bigtable.v1.RowFilter.block_all_filter', index=5, + number=18, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='row_key_regex_filter', full_name='google.bigtable.v1.RowFilter.row_key_regex_filter', index=6, + number=4, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='row_sample_filter', full_name='google.bigtable.v1.RowFilter.row_sample_filter', index=7, + number=14, type=1, cpp_type=5, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='family_name_regex_filter', full_name='google.bigtable.v1.RowFilter.family_name_regex_filter', index=8, + number=5, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='column_qualifier_regex_filter', full_name='google.bigtable.v1.RowFilter.column_qualifier_regex_filter', index=9, + number=6, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='column_range_filter', full_name='google.bigtable.v1.RowFilter.column_range_filter', index=10, + number=7, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='timestamp_range_filter', full_name='google.bigtable.v1.RowFilter.timestamp_range_filter', index=11, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value_regex_filter', full_name='google.bigtable.v1.RowFilter.value_regex_filter', index=12, + number=9, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value_range_filter', full_name='google.bigtable.v1.RowFilter.value_range_filter', index=13, + number=15, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='cells_per_row_offset_filter', full_name='google.bigtable.v1.RowFilter.cells_per_row_offset_filter', index=14, + number=10, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='cells_per_row_limit_filter', full_name='google.bigtable.v1.RowFilter.cells_per_row_limit_filter', index=15, + number=11, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='cells_per_column_limit_filter', full_name='google.bigtable.v1.RowFilter.cells_per_column_limit_filter', index=16, + number=12, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='strip_value_transformer', full_name='google.bigtable.v1.RowFilter.strip_value_transformer', index=17, + number=13, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='apply_label_transformer', full_name='google.bigtable.v1.RowFilter.apply_label_transformer', index=18, + number=19, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_ROWFILTER_CHAIN, _ROWFILTER_INTERLEAVE, _ROWFILTER_CONDITION, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='filter', full_name='google.bigtable.v1.RowFilter.filter', + index=0, containing_type=None, fields=[]), + ], + serialized_start=849, + serialized_end=1968, +) + + +_MUTATION_SETCELL = _descriptor.Descriptor( + name='SetCell', + full_name='google.bigtable.v1.Mutation.SetCell', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='family_name', full_name='google.bigtable.v1.Mutation.SetCell.family_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='column_qualifier', full_name='google.bigtable.v1.Mutation.SetCell.column_qualifier', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='timestamp_micros', full_name='google.bigtable.v1.Mutation.SetCell.timestamp_micros', index=2, + number=3, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='google.bigtable.v1.Mutation.SetCell.value', index=3, + number=4, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2266, + serialized_end=2363, +) + +_MUTATION_DELETEFROMCOLUMN = _descriptor.Descriptor( + name='DeleteFromColumn', + full_name='google.bigtable.v1.Mutation.DeleteFromColumn', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='family_name', full_name='google.bigtable.v1.Mutation.DeleteFromColumn.family_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='column_qualifier', full_name='google.bigtable.v1.Mutation.DeleteFromColumn.column_qualifier', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='time_range', full_name='google.bigtable.v1.Mutation.DeleteFromColumn.time_range', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2365, + serialized_end=2486, +) + +_MUTATION_DELETEFROMFAMILY = _descriptor.Descriptor( + name='DeleteFromFamily', + full_name='google.bigtable.v1.Mutation.DeleteFromFamily', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='family_name', full_name='google.bigtable.v1.Mutation.DeleteFromFamily.family_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2488, + serialized_end=2527, +) + +_MUTATION_DELETEFROMROW = _descriptor.Descriptor( + name='DeleteFromRow', + full_name='google.bigtable.v1.Mutation.DeleteFromRow', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=2529, + serialized_end=2544, +) + +_MUTATION = _descriptor.Descriptor( + name='Mutation', + full_name='google.bigtable.v1.Mutation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='set_cell', full_name='google.bigtable.v1.Mutation.set_cell', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='delete_from_column', full_name='google.bigtable.v1.Mutation.delete_from_column', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='delete_from_family', full_name='google.bigtable.v1.Mutation.delete_from_family', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='delete_from_row', full_name='google.bigtable.v1.Mutation.delete_from_row', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_MUTATION_SETCELL, _MUTATION_DELETEFROMCOLUMN, _MUTATION_DELETEFROMFAMILY, _MUTATION_DELETEFROMROW, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='mutation', full_name='google.bigtable.v1.Mutation.mutation', + index=0, containing_type=None, fields=[]), + ], + serialized_start=1971, + serialized_end=2556, +) + + +_READMODIFYWRITERULE = _descriptor.Descriptor( + name='ReadModifyWriteRule', + full_name='google.bigtable.v1.ReadModifyWriteRule', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='family_name', full_name='google.bigtable.v1.ReadModifyWriteRule.family_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='column_qualifier', full_name='google.bigtable.v1.ReadModifyWriteRule.column_qualifier', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='append_value', full_name='google.bigtable.v1.ReadModifyWriteRule.append_value', index=2, + number=3, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='increment_amount', full_name='google.bigtable.v1.ReadModifyWriteRule.increment_amount', index=3, + number=4, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='rule', full_name='google.bigtable.v1.ReadModifyWriteRule.rule', + index=0, containing_type=None, fields=[]), + ], + serialized_start=2559, + serialized_end=2687, +) + +_ROW.fields_by_name['families'].message_type = _FAMILY +_FAMILY.fields_by_name['columns'].message_type = _COLUMN +_COLUMN.fields_by_name['cells'].message_type = _CELL +_COLUMNRANGE.oneofs_by_name['start_qualifier'].fields.append( + _COLUMNRANGE.fields_by_name['start_qualifier_inclusive']) +_COLUMNRANGE.fields_by_name['start_qualifier_inclusive'].containing_oneof = _COLUMNRANGE.oneofs_by_name['start_qualifier'] +_COLUMNRANGE.oneofs_by_name['start_qualifier'].fields.append( + _COLUMNRANGE.fields_by_name['start_qualifier_exclusive']) +_COLUMNRANGE.fields_by_name['start_qualifier_exclusive'].containing_oneof = _COLUMNRANGE.oneofs_by_name['start_qualifier'] +_COLUMNRANGE.oneofs_by_name['end_qualifier'].fields.append( + _COLUMNRANGE.fields_by_name['end_qualifier_inclusive']) +_COLUMNRANGE.fields_by_name['end_qualifier_inclusive'].containing_oneof = _COLUMNRANGE.oneofs_by_name['end_qualifier'] +_COLUMNRANGE.oneofs_by_name['end_qualifier'].fields.append( + _COLUMNRANGE.fields_by_name['end_qualifier_exclusive']) +_COLUMNRANGE.fields_by_name['end_qualifier_exclusive'].containing_oneof = _COLUMNRANGE.oneofs_by_name['end_qualifier'] +_VALUERANGE.oneofs_by_name['start_value'].fields.append( + _VALUERANGE.fields_by_name['start_value_inclusive']) +_VALUERANGE.fields_by_name['start_value_inclusive'].containing_oneof = _VALUERANGE.oneofs_by_name['start_value'] +_VALUERANGE.oneofs_by_name['start_value'].fields.append( + _VALUERANGE.fields_by_name['start_value_exclusive']) +_VALUERANGE.fields_by_name['start_value_exclusive'].containing_oneof = _VALUERANGE.oneofs_by_name['start_value'] +_VALUERANGE.oneofs_by_name['end_value'].fields.append( + _VALUERANGE.fields_by_name['end_value_inclusive']) +_VALUERANGE.fields_by_name['end_value_inclusive'].containing_oneof = _VALUERANGE.oneofs_by_name['end_value'] +_VALUERANGE.oneofs_by_name['end_value'].fields.append( + _VALUERANGE.fields_by_name['end_value_exclusive']) +_VALUERANGE.fields_by_name['end_value_exclusive'].containing_oneof = _VALUERANGE.oneofs_by_name['end_value'] +_ROWFILTER_CHAIN.fields_by_name['filters'].message_type = _ROWFILTER +_ROWFILTER_CHAIN.containing_type = _ROWFILTER +_ROWFILTER_INTERLEAVE.fields_by_name['filters'].message_type = _ROWFILTER +_ROWFILTER_INTERLEAVE.containing_type = _ROWFILTER +_ROWFILTER_CONDITION.fields_by_name['predicate_filter'].message_type = _ROWFILTER +_ROWFILTER_CONDITION.fields_by_name['true_filter'].message_type = _ROWFILTER +_ROWFILTER_CONDITION.fields_by_name['false_filter'].message_type = _ROWFILTER +_ROWFILTER_CONDITION.containing_type = _ROWFILTER +_ROWFILTER.fields_by_name['chain'].message_type = _ROWFILTER_CHAIN +_ROWFILTER.fields_by_name['interleave'].message_type = _ROWFILTER_INTERLEAVE +_ROWFILTER.fields_by_name['condition'].message_type = _ROWFILTER_CONDITION +_ROWFILTER.fields_by_name['column_range_filter'].message_type = _COLUMNRANGE +_ROWFILTER.fields_by_name['timestamp_range_filter'].message_type = _TIMESTAMPRANGE +_ROWFILTER.fields_by_name['value_range_filter'].message_type = _VALUERANGE +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['chain']) +_ROWFILTER.fields_by_name['chain'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['interleave']) +_ROWFILTER.fields_by_name['interleave'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['condition']) +_ROWFILTER.fields_by_name['condition'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['sink']) +_ROWFILTER.fields_by_name['sink'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['pass_all_filter']) +_ROWFILTER.fields_by_name['pass_all_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['block_all_filter']) +_ROWFILTER.fields_by_name['block_all_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['row_key_regex_filter']) +_ROWFILTER.fields_by_name['row_key_regex_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['row_sample_filter']) +_ROWFILTER.fields_by_name['row_sample_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['family_name_regex_filter']) +_ROWFILTER.fields_by_name['family_name_regex_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['column_qualifier_regex_filter']) +_ROWFILTER.fields_by_name['column_qualifier_regex_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['column_range_filter']) +_ROWFILTER.fields_by_name['column_range_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['timestamp_range_filter']) +_ROWFILTER.fields_by_name['timestamp_range_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['value_regex_filter']) +_ROWFILTER.fields_by_name['value_regex_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['value_range_filter']) +_ROWFILTER.fields_by_name['value_range_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['cells_per_row_offset_filter']) +_ROWFILTER.fields_by_name['cells_per_row_offset_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['cells_per_row_limit_filter']) +_ROWFILTER.fields_by_name['cells_per_row_limit_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['cells_per_column_limit_filter']) +_ROWFILTER.fields_by_name['cells_per_column_limit_filter'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['strip_value_transformer']) +_ROWFILTER.fields_by_name['strip_value_transformer'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_ROWFILTER.oneofs_by_name['filter'].fields.append( + _ROWFILTER.fields_by_name['apply_label_transformer']) +_ROWFILTER.fields_by_name['apply_label_transformer'].containing_oneof = _ROWFILTER.oneofs_by_name['filter'] +_MUTATION_SETCELL.containing_type = _MUTATION +_MUTATION_DELETEFROMCOLUMN.fields_by_name['time_range'].message_type = _TIMESTAMPRANGE +_MUTATION_DELETEFROMCOLUMN.containing_type = _MUTATION +_MUTATION_DELETEFROMFAMILY.containing_type = _MUTATION +_MUTATION_DELETEFROMROW.containing_type = _MUTATION +_MUTATION.fields_by_name['set_cell'].message_type = _MUTATION_SETCELL +_MUTATION.fields_by_name['delete_from_column'].message_type = _MUTATION_DELETEFROMCOLUMN +_MUTATION.fields_by_name['delete_from_family'].message_type = _MUTATION_DELETEFROMFAMILY +_MUTATION.fields_by_name['delete_from_row'].message_type = _MUTATION_DELETEFROMROW +_MUTATION.oneofs_by_name['mutation'].fields.append( + _MUTATION.fields_by_name['set_cell']) +_MUTATION.fields_by_name['set_cell'].containing_oneof = _MUTATION.oneofs_by_name['mutation'] +_MUTATION.oneofs_by_name['mutation'].fields.append( + _MUTATION.fields_by_name['delete_from_column']) +_MUTATION.fields_by_name['delete_from_column'].containing_oneof = _MUTATION.oneofs_by_name['mutation'] +_MUTATION.oneofs_by_name['mutation'].fields.append( + _MUTATION.fields_by_name['delete_from_family']) +_MUTATION.fields_by_name['delete_from_family'].containing_oneof = _MUTATION.oneofs_by_name['mutation'] +_MUTATION.oneofs_by_name['mutation'].fields.append( + _MUTATION.fields_by_name['delete_from_row']) +_MUTATION.fields_by_name['delete_from_row'].containing_oneof = _MUTATION.oneofs_by_name['mutation'] +_READMODIFYWRITERULE.oneofs_by_name['rule'].fields.append( + _READMODIFYWRITERULE.fields_by_name['append_value']) +_READMODIFYWRITERULE.fields_by_name['append_value'].containing_oneof = _READMODIFYWRITERULE.oneofs_by_name['rule'] +_READMODIFYWRITERULE.oneofs_by_name['rule'].fields.append( + _READMODIFYWRITERULE.fields_by_name['increment_amount']) +_READMODIFYWRITERULE.fields_by_name['increment_amount'].containing_oneof = _READMODIFYWRITERULE.oneofs_by_name['rule'] +DESCRIPTOR.message_types_by_name['Row'] = _ROW +DESCRIPTOR.message_types_by_name['Family'] = _FAMILY +DESCRIPTOR.message_types_by_name['Column'] = _COLUMN +DESCRIPTOR.message_types_by_name['Cell'] = _CELL +DESCRIPTOR.message_types_by_name['RowRange'] = _ROWRANGE +DESCRIPTOR.message_types_by_name['ColumnRange'] = _COLUMNRANGE +DESCRIPTOR.message_types_by_name['TimestampRange'] = _TIMESTAMPRANGE +DESCRIPTOR.message_types_by_name['ValueRange'] = _VALUERANGE +DESCRIPTOR.message_types_by_name['RowFilter'] = _ROWFILTER +DESCRIPTOR.message_types_by_name['Mutation'] = _MUTATION +DESCRIPTOR.message_types_by_name['ReadModifyWriteRule'] = _READMODIFYWRITERULE + +Row = _reflection.GeneratedProtocolMessageType('Row', (_message.Message,), dict( + DESCRIPTOR = _ROW, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Row) + )) +_sym_db.RegisterMessage(Row) + +Family = _reflection.GeneratedProtocolMessageType('Family', (_message.Message,), dict( + DESCRIPTOR = _FAMILY, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Family) + )) +_sym_db.RegisterMessage(Family) + +Column = _reflection.GeneratedProtocolMessageType('Column', (_message.Message,), dict( + DESCRIPTOR = _COLUMN, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Column) + )) +_sym_db.RegisterMessage(Column) + +Cell = _reflection.GeneratedProtocolMessageType('Cell', (_message.Message,), dict( + DESCRIPTOR = _CELL, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Cell) + )) +_sym_db.RegisterMessage(Cell) + +RowRange = _reflection.GeneratedProtocolMessageType('RowRange', (_message.Message,), dict( + DESCRIPTOR = _ROWRANGE, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.RowRange) + )) +_sym_db.RegisterMessage(RowRange) + +ColumnRange = _reflection.GeneratedProtocolMessageType('ColumnRange', (_message.Message,), dict( + DESCRIPTOR = _COLUMNRANGE, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.ColumnRange) + )) +_sym_db.RegisterMessage(ColumnRange) + +TimestampRange = _reflection.GeneratedProtocolMessageType('TimestampRange', (_message.Message,), dict( + DESCRIPTOR = _TIMESTAMPRANGE, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.TimestampRange) + )) +_sym_db.RegisterMessage(TimestampRange) + +ValueRange = _reflection.GeneratedProtocolMessageType('ValueRange', (_message.Message,), dict( + DESCRIPTOR = _VALUERANGE, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.ValueRange) + )) +_sym_db.RegisterMessage(ValueRange) + +RowFilter = _reflection.GeneratedProtocolMessageType('RowFilter', (_message.Message,), dict( + + Chain = _reflection.GeneratedProtocolMessageType('Chain', (_message.Message,), dict( + DESCRIPTOR = _ROWFILTER_CHAIN, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.RowFilter.Chain) + )) + , + + Interleave = _reflection.GeneratedProtocolMessageType('Interleave', (_message.Message,), dict( + DESCRIPTOR = _ROWFILTER_INTERLEAVE, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.RowFilter.Interleave) + )) + , + + Condition = _reflection.GeneratedProtocolMessageType('Condition', (_message.Message,), dict( + DESCRIPTOR = _ROWFILTER_CONDITION, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.RowFilter.Condition) + )) + , + DESCRIPTOR = _ROWFILTER, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.RowFilter) + )) +_sym_db.RegisterMessage(RowFilter) +_sym_db.RegisterMessage(RowFilter.Chain) +_sym_db.RegisterMessage(RowFilter.Interleave) +_sym_db.RegisterMessage(RowFilter.Condition) + +Mutation = _reflection.GeneratedProtocolMessageType('Mutation', (_message.Message,), dict( + + SetCell = _reflection.GeneratedProtocolMessageType('SetCell', (_message.Message,), dict( + DESCRIPTOR = _MUTATION_SETCELL, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Mutation.SetCell) + )) + , + + DeleteFromColumn = _reflection.GeneratedProtocolMessageType('DeleteFromColumn', (_message.Message,), dict( + DESCRIPTOR = _MUTATION_DELETEFROMCOLUMN, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Mutation.DeleteFromColumn) + )) + , + + DeleteFromFamily = _reflection.GeneratedProtocolMessageType('DeleteFromFamily', (_message.Message,), dict( + DESCRIPTOR = _MUTATION_DELETEFROMFAMILY, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Mutation.DeleteFromFamily) + )) + , + + DeleteFromRow = _reflection.GeneratedProtocolMessageType('DeleteFromRow', (_message.Message,), dict( + DESCRIPTOR = _MUTATION_DELETEFROMROW, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Mutation.DeleteFromRow) + )) + , + DESCRIPTOR = _MUTATION, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.Mutation) + )) +_sym_db.RegisterMessage(Mutation) +_sym_db.RegisterMessage(Mutation.SetCell) +_sym_db.RegisterMessage(Mutation.DeleteFromColumn) +_sym_db.RegisterMessage(Mutation.DeleteFromFamily) +_sym_db.RegisterMessage(Mutation.DeleteFromRow) + +ReadModifyWriteRule = _reflection.GeneratedProtocolMessageType('ReadModifyWriteRule', (_message.Message,), dict( + DESCRIPTOR = _READMODIFYWRITERULE, + __module__ = 'google.bigtable.v1.bigtable_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.ReadModifyWriteRule) + )) +_sym_db.RegisterMessage(ReadModifyWriteRule) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\026com.google.bigtable.v1B\021BigtableDataProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/bigtable_service_messages_pb2.py b/gcloud/bigtable/_generated/bigtable_service_messages_pb2.py new file mode 100644 index 000000000000..b7920d2d5684 --- /dev/null +++ b/gcloud/bigtable/_generated/bigtable_service_messages_pb2.py @@ -0,0 +1,537 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/bigtable/v1/bigtable_service_messages.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import bigtable_data_pb2 as google_dot_bigtable_dot_v1_dot_bigtable__data__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/bigtable/v1/bigtable_service_messages.proto', + package='google.bigtable.v1', + syntax='proto3', + serialized_pb=_b('\n2google/bigtable/v1/bigtable_service_messages.proto\x12\x12google.bigtable.v1\x1a&google/bigtable/v1/bigtable_data.proto\"\xdc\x01\n\x0fReadRowsRequest\x12\x12\n\ntable_name\x18\x01 \x01(\t\x12\x11\n\x07row_key\x18\x02 \x01(\x0cH\x00\x12\x31\n\trow_range\x18\x03 \x01(\x0b\x32\x1c.google.bigtable.v1.RowRangeH\x00\x12-\n\x06\x66ilter\x18\x05 \x01(\x0b\x32\x1d.google.bigtable.v1.RowFilter\x12\x1e\n\x16\x61llow_row_interleaving\x18\x06 \x01(\x08\x12\x16\n\x0enum_rows_limit\x18\x07 \x01(\x03\x42\x08\n\x06target\"\xd0\x01\n\x10ReadRowsResponse\x12\x0f\n\x07row_key\x18\x01 \x01(\x0c\x12:\n\x06\x63hunks\x18\x02 \x03(\x0b\x32*.google.bigtable.v1.ReadRowsResponse.Chunk\x1ao\n\x05\x43hunk\x12\x32\n\x0crow_contents\x18\x01 \x01(\x0b\x32\x1a.google.bigtable.v1.FamilyH\x00\x12\x13\n\treset_row\x18\x02 \x01(\x08H\x00\x12\x14\n\ncommit_row\x18\x03 \x01(\x08H\x00\x42\x07\n\x05\x63hunk\"*\n\x14SampleRowKeysRequest\x12\x12\n\ntable_name\x18\x01 \x01(\t\">\n\x15SampleRowKeysResponse\x12\x0f\n\x07row_key\x18\x01 \x01(\x0c\x12\x14\n\x0coffset_bytes\x18\x02 \x01(\x03\"h\n\x10MutateRowRequest\x12\x12\n\ntable_name\x18\x01 \x01(\t\x12\x0f\n\x07row_key\x18\x02 \x01(\x0c\x12/\n\tmutations\x18\x03 \x03(\x0b\x32\x1c.google.bigtable.v1.Mutation\"\xe5\x01\n\x18\x43heckAndMutateRowRequest\x12\x12\n\ntable_name\x18\x01 \x01(\t\x12\x0f\n\x07row_key\x18\x02 \x01(\x0c\x12\x37\n\x10predicate_filter\x18\x06 \x01(\x0b\x32\x1d.google.bigtable.v1.RowFilter\x12\x34\n\x0etrue_mutations\x18\x04 \x03(\x0b\x32\x1c.google.bigtable.v1.Mutation\x12\x35\n\x0f\x66\x61lse_mutations\x18\x05 \x03(\x0b\x32\x1c.google.bigtable.v1.Mutation\"6\n\x19\x43heckAndMutateRowResponse\x12\x19\n\x11predicate_matched\x18\x01 \x01(\x08\"x\n\x19ReadModifyWriteRowRequest\x12\x12\n\ntable_name\x18\x01 \x01(\t\x12\x0f\n\x07row_key\x18\x02 \x01(\x0c\x12\x36\n\x05rules\x18\x03 \x03(\x0b\x32\'.google.bigtable.v1.ReadModifyWriteRuleB8\n\x16\x63om.google.bigtable.v1B\x1c\x42igtableServiceMessagesProtoP\x01\x62\x06proto3') + , + dependencies=[google_dot_bigtable_dot_v1_dot_bigtable__data__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_READROWSREQUEST = _descriptor.Descriptor( + name='ReadRowsRequest', + full_name='google.bigtable.v1.ReadRowsRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='table_name', full_name='google.bigtable.v1.ReadRowsRequest.table_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='row_key', full_name='google.bigtable.v1.ReadRowsRequest.row_key', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='row_range', full_name='google.bigtable.v1.ReadRowsRequest.row_range', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='filter', full_name='google.bigtable.v1.ReadRowsRequest.filter', index=3, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='allow_row_interleaving', full_name='google.bigtable.v1.ReadRowsRequest.allow_row_interleaving', index=4, + number=6, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='num_rows_limit', full_name='google.bigtable.v1.ReadRowsRequest.num_rows_limit', index=5, + number=7, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='target', full_name='google.bigtable.v1.ReadRowsRequest.target', + index=0, containing_type=None, fields=[]), + ], + serialized_start=115, + serialized_end=335, +) + + +_READROWSRESPONSE_CHUNK = _descriptor.Descriptor( + name='Chunk', + full_name='google.bigtable.v1.ReadRowsResponse.Chunk', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='row_contents', full_name='google.bigtable.v1.ReadRowsResponse.Chunk.row_contents', index=0, + number=1, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='reset_row', full_name='google.bigtable.v1.ReadRowsResponse.Chunk.reset_row', index=1, + number=2, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='commit_row', full_name='google.bigtable.v1.ReadRowsResponse.Chunk.commit_row', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='chunk', full_name='google.bigtable.v1.ReadRowsResponse.Chunk.chunk', + index=0, containing_type=None, fields=[]), + ], + serialized_start=435, + serialized_end=546, +) + +_READROWSRESPONSE = _descriptor.Descriptor( + name='ReadRowsResponse', + full_name='google.bigtable.v1.ReadRowsResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='row_key', full_name='google.bigtable.v1.ReadRowsResponse.row_key', index=0, + number=1, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='chunks', full_name='google.bigtable.v1.ReadRowsResponse.chunks', index=1, + number=2, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_READROWSRESPONSE_CHUNK, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=338, + serialized_end=546, +) + + +_SAMPLEROWKEYSREQUEST = _descriptor.Descriptor( + name='SampleRowKeysRequest', + full_name='google.bigtable.v1.SampleRowKeysRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='table_name', full_name='google.bigtable.v1.SampleRowKeysRequest.table_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=548, + serialized_end=590, +) + + +_SAMPLEROWKEYSRESPONSE = _descriptor.Descriptor( + name='SampleRowKeysResponse', + full_name='google.bigtable.v1.SampleRowKeysResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='row_key', full_name='google.bigtable.v1.SampleRowKeysResponse.row_key', index=0, + number=1, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='offset_bytes', full_name='google.bigtable.v1.SampleRowKeysResponse.offset_bytes', index=1, + number=2, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=592, + serialized_end=654, +) + + +_MUTATEROWREQUEST = _descriptor.Descriptor( + name='MutateRowRequest', + full_name='google.bigtable.v1.MutateRowRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='table_name', full_name='google.bigtable.v1.MutateRowRequest.table_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='row_key', full_name='google.bigtable.v1.MutateRowRequest.row_key', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='mutations', full_name='google.bigtable.v1.MutateRowRequest.mutations', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=656, + serialized_end=760, +) + + +_CHECKANDMUTATEROWREQUEST = _descriptor.Descriptor( + name='CheckAndMutateRowRequest', + full_name='google.bigtable.v1.CheckAndMutateRowRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='table_name', full_name='google.bigtable.v1.CheckAndMutateRowRequest.table_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='row_key', full_name='google.bigtable.v1.CheckAndMutateRowRequest.row_key', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='predicate_filter', full_name='google.bigtable.v1.CheckAndMutateRowRequest.predicate_filter', index=2, + number=6, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='true_mutations', full_name='google.bigtable.v1.CheckAndMutateRowRequest.true_mutations', index=3, + number=4, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='false_mutations', full_name='google.bigtable.v1.CheckAndMutateRowRequest.false_mutations', index=4, + number=5, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=763, + serialized_end=992, +) + + +_CHECKANDMUTATEROWRESPONSE = _descriptor.Descriptor( + name='CheckAndMutateRowResponse', + full_name='google.bigtable.v1.CheckAndMutateRowResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='predicate_matched', full_name='google.bigtable.v1.CheckAndMutateRowResponse.predicate_matched', index=0, + number=1, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=994, + serialized_end=1048, +) + + +_READMODIFYWRITEROWREQUEST = _descriptor.Descriptor( + name='ReadModifyWriteRowRequest', + full_name='google.bigtable.v1.ReadModifyWriteRowRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='table_name', full_name='google.bigtable.v1.ReadModifyWriteRowRequest.table_name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='row_key', full_name='google.bigtable.v1.ReadModifyWriteRowRequest.row_key', index=1, + number=2, type=12, cpp_type=9, label=1, + has_default_value=False, default_value=_b(""), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='rules', full_name='google.bigtable.v1.ReadModifyWriteRowRequest.rules', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=1050, + serialized_end=1170, +) + +_READROWSREQUEST.fields_by_name['row_range'].message_type = google_dot_bigtable_dot_v1_dot_bigtable__data__pb2._ROWRANGE +_READROWSREQUEST.fields_by_name['filter'].message_type = google_dot_bigtable_dot_v1_dot_bigtable__data__pb2._ROWFILTER +_READROWSREQUEST.oneofs_by_name['target'].fields.append( + _READROWSREQUEST.fields_by_name['row_key']) +_READROWSREQUEST.fields_by_name['row_key'].containing_oneof = _READROWSREQUEST.oneofs_by_name['target'] +_READROWSREQUEST.oneofs_by_name['target'].fields.append( + _READROWSREQUEST.fields_by_name['row_range']) +_READROWSREQUEST.fields_by_name['row_range'].containing_oneof = _READROWSREQUEST.oneofs_by_name['target'] +_READROWSRESPONSE_CHUNK.fields_by_name['row_contents'].message_type = google_dot_bigtable_dot_v1_dot_bigtable__data__pb2._FAMILY +_READROWSRESPONSE_CHUNK.containing_type = _READROWSRESPONSE +_READROWSRESPONSE_CHUNK.oneofs_by_name['chunk'].fields.append( + _READROWSRESPONSE_CHUNK.fields_by_name['row_contents']) +_READROWSRESPONSE_CHUNK.fields_by_name['row_contents'].containing_oneof = _READROWSRESPONSE_CHUNK.oneofs_by_name['chunk'] +_READROWSRESPONSE_CHUNK.oneofs_by_name['chunk'].fields.append( + _READROWSRESPONSE_CHUNK.fields_by_name['reset_row']) +_READROWSRESPONSE_CHUNK.fields_by_name['reset_row'].containing_oneof = _READROWSRESPONSE_CHUNK.oneofs_by_name['chunk'] +_READROWSRESPONSE_CHUNK.oneofs_by_name['chunk'].fields.append( + _READROWSRESPONSE_CHUNK.fields_by_name['commit_row']) +_READROWSRESPONSE_CHUNK.fields_by_name['commit_row'].containing_oneof = _READROWSRESPONSE_CHUNK.oneofs_by_name['chunk'] +_READROWSRESPONSE.fields_by_name['chunks'].message_type = _READROWSRESPONSE_CHUNK +_MUTATEROWREQUEST.fields_by_name['mutations'].message_type = google_dot_bigtable_dot_v1_dot_bigtable__data__pb2._MUTATION +_CHECKANDMUTATEROWREQUEST.fields_by_name['predicate_filter'].message_type = google_dot_bigtable_dot_v1_dot_bigtable__data__pb2._ROWFILTER +_CHECKANDMUTATEROWREQUEST.fields_by_name['true_mutations'].message_type = google_dot_bigtable_dot_v1_dot_bigtable__data__pb2._MUTATION +_CHECKANDMUTATEROWREQUEST.fields_by_name['false_mutations'].message_type = google_dot_bigtable_dot_v1_dot_bigtable__data__pb2._MUTATION +_READMODIFYWRITEROWREQUEST.fields_by_name['rules'].message_type = google_dot_bigtable_dot_v1_dot_bigtable__data__pb2._READMODIFYWRITERULE +DESCRIPTOR.message_types_by_name['ReadRowsRequest'] = _READROWSREQUEST +DESCRIPTOR.message_types_by_name['ReadRowsResponse'] = _READROWSRESPONSE +DESCRIPTOR.message_types_by_name['SampleRowKeysRequest'] = _SAMPLEROWKEYSREQUEST +DESCRIPTOR.message_types_by_name['SampleRowKeysResponse'] = _SAMPLEROWKEYSRESPONSE +DESCRIPTOR.message_types_by_name['MutateRowRequest'] = _MUTATEROWREQUEST +DESCRIPTOR.message_types_by_name['CheckAndMutateRowRequest'] = _CHECKANDMUTATEROWREQUEST +DESCRIPTOR.message_types_by_name['CheckAndMutateRowResponse'] = _CHECKANDMUTATEROWRESPONSE +DESCRIPTOR.message_types_by_name['ReadModifyWriteRowRequest'] = _READMODIFYWRITEROWREQUEST + +ReadRowsRequest = _reflection.GeneratedProtocolMessageType('ReadRowsRequest', (_message.Message,), dict( + DESCRIPTOR = _READROWSREQUEST, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.ReadRowsRequest) + )) +_sym_db.RegisterMessage(ReadRowsRequest) + +ReadRowsResponse = _reflection.GeneratedProtocolMessageType('ReadRowsResponse', (_message.Message,), dict( + + Chunk = _reflection.GeneratedProtocolMessageType('Chunk', (_message.Message,), dict( + DESCRIPTOR = _READROWSRESPONSE_CHUNK, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.ReadRowsResponse.Chunk) + )) + , + DESCRIPTOR = _READROWSRESPONSE, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.ReadRowsResponse) + )) +_sym_db.RegisterMessage(ReadRowsResponse) +_sym_db.RegisterMessage(ReadRowsResponse.Chunk) + +SampleRowKeysRequest = _reflection.GeneratedProtocolMessageType('SampleRowKeysRequest', (_message.Message,), dict( + DESCRIPTOR = _SAMPLEROWKEYSREQUEST, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.SampleRowKeysRequest) + )) +_sym_db.RegisterMessage(SampleRowKeysRequest) + +SampleRowKeysResponse = _reflection.GeneratedProtocolMessageType('SampleRowKeysResponse', (_message.Message,), dict( + DESCRIPTOR = _SAMPLEROWKEYSRESPONSE, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.SampleRowKeysResponse) + )) +_sym_db.RegisterMessage(SampleRowKeysResponse) + +MutateRowRequest = _reflection.GeneratedProtocolMessageType('MutateRowRequest', (_message.Message,), dict( + DESCRIPTOR = _MUTATEROWREQUEST, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.MutateRowRequest) + )) +_sym_db.RegisterMessage(MutateRowRequest) + +CheckAndMutateRowRequest = _reflection.GeneratedProtocolMessageType('CheckAndMutateRowRequest', (_message.Message,), dict( + DESCRIPTOR = _CHECKANDMUTATEROWREQUEST, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.CheckAndMutateRowRequest) + )) +_sym_db.RegisterMessage(CheckAndMutateRowRequest) + +CheckAndMutateRowResponse = _reflection.GeneratedProtocolMessageType('CheckAndMutateRowResponse', (_message.Message,), dict( + DESCRIPTOR = _CHECKANDMUTATEROWRESPONSE, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.CheckAndMutateRowResponse) + )) +_sym_db.RegisterMessage(CheckAndMutateRowResponse) + +ReadModifyWriteRowRequest = _reflection.GeneratedProtocolMessageType('ReadModifyWriteRowRequest', (_message.Message,), dict( + DESCRIPTOR = _READMODIFYWRITEROWREQUEST, + __module__ = 'google.bigtable.v1.bigtable_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.v1.ReadModifyWriteRowRequest) + )) +_sym_db.RegisterMessage(ReadModifyWriteRowRequest) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\026com.google.bigtable.v1B\034BigtableServiceMessagesProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/bigtable_service_pb2.py b/gcloud/bigtable/_generated/bigtable_service_pb2.py new file mode 100644 index 000000000000..f7cd105eacd1 --- /dev/null +++ b/gcloud/bigtable/_generated/bigtable_service_pb2.py @@ -0,0 +1,163 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/bigtable/v1/bigtable_service.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from gcloud.bigtable._generated import bigtable_data_pb2 as google_dot_bigtable_dot_v1_dot_bigtable__data__pb2 +from gcloud.bigtable._generated import bigtable_service_messages_pb2 as google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2 +from gcloud.bigtable._generated import empty_pb2 as google_dot_protobuf_dot_empty__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/bigtable/v1/bigtable_service.proto', + package='google.bigtable.v1', + syntax='proto3', + serialized_pb=_b('\n)google/bigtable/v1/bigtable_service.proto\x12\x12google.bigtable.v1\x1a\x1cgoogle/api/annotations.proto\x1a&google/bigtable/v1/bigtable_data.proto\x1a\x32google/bigtable/v1/bigtable_service_messages.proto\x1a\x1bgoogle/protobuf/empty.proto2\xb0\x07\n\x0f\x42igtableService\x12\xa5\x01\n\x08ReadRows\x12#.google.bigtable.v1.ReadRowsRequest\x1a$.google.bigtable.v1.ReadRowsResponse\"L\x82\xd3\xe4\x93\x02\x46\"A/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows:read:\x01*0\x01\x12\xb7\x01\n\rSampleRowKeys\x12(.google.bigtable.v1.SampleRowKeysRequest\x1a).google.bigtable.v1.SampleRowKeysResponse\"O\x82\xd3\xe4\x93\x02I\x12G/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows:sampleKeys0\x01\x12\xa3\x01\n\tMutateRow\x12$.google.bigtable.v1.MutateRowRequest\x1a\x16.google.protobuf.Empty\"X\x82\xd3\xe4\x93\x02R\"M/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows/{row_key}:mutate:\x01*\x12\xd2\x01\n\x11\x43heckAndMutateRow\x12,.google.bigtable.v1.CheckAndMutateRowRequest\x1a-.google.bigtable.v1.CheckAndMutateRowResponse\"`\x82\xd3\xe4\x93\x02Z\"U/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows/{row_key}:checkAndMutate:\x01*\x12\xbf\x01\n\x12ReadModifyWriteRow\x12-.google.bigtable.v1.ReadModifyWriteRowRequest\x1a\x17.google.bigtable.v1.Row\"a\x82\xd3\xe4\x93\x02[\"V/v1/{table_name=projects/*/zones/*/clusters/*/tables/*}/rows/{row_key}:readModifyWrite:\x01*B4\n\x16\x63om.google.bigtable.v1B\x15\x42igtableServicesProtoP\x01\x88\x01\x01\x62\x06proto3') + , + dependencies=[google_dot_api_dot_annotations__pb2.DESCRIPTOR,google_dot_bigtable_dot_v1_dot_bigtable__data__pb2.DESCRIPTOR,google_dot_bigtable_dot_v1_dot_bigtable__service__messages__pb2.DESCRIPTOR,google_dot_protobuf_dot_empty__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\026com.google.bigtable.v1B\025BigtableServicesProtoP\001\210\001\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +class EarlyAdopterBigtableServiceServicer(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def ReadRows(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def SampleRowKeys(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def MutateRow(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def CheckAndMutateRow(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def ReadModifyWriteRow(self, request, context): + raise NotImplementedError() +class EarlyAdopterBigtableServiceServer(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def start(self): + raise NotImplementedError() + @abc.abstractmethod + def stop(self): + raise NotImplementedError() +class EarlyAdopterBigtableServiceStub(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def ReadRows(self, request): + raise NotImplementedError() + ReadRows.async = None + @abc.abstractmethod + def SampleRowKeys(self, request): + raise NotImplementedError() + SampleRowKeys.async = None + @abc.abstractmethod + def MutateRow(self, request): + raise NotImplementedError() + MutateRow.async = None + @abc.abstractmethod + def CheckAndMutateRow(self, request): + raise NotImplementedError() + CheckAndMutateRow.async = None + @abc.abstractmethod + def ReadModifyWriteRow(self, request): + raise NotImplementedError() + ReadModifyWriteRow.async = None +def early_adopter_create_BigtableService_server(servicer, port, private_key=None, certificate_chain=None): + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_data_pb2 + method_service_descriptions = { + "CheckAndMutateRow": utilities.unary_unary_service_description( + servicer.CheckAndMutateRow, + gcloud.bigtable._generated.bigtable_service_messages_pb2.CheckAndMutateRowRequest.FromString, + gcloud.bigtable._generated.bigtable_service_messages_pb2.CheckAndMutateRowResponse.SerializeToString, + ), + "MutateRow": utilities.unary_unary_service_description( + servicer.MutateRow, + gcloud.bigtable._generated.bigtable_service_messages_pb2.MutateRowRequest.FromString, + gcloud.bigtable._generated.empty_pb2.Empty.SerializeToString, + ), + "ReadModifyWriteRow": utilities.unary_unary_service_description( + servicer.ReadModifyWriteRow, + gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadModifyWriteRowRequest.FromString, + gcloud.bigtable._generated.bigtable_data_pb2.Row.SerializeToString, + ), + "ReadRows": utilities.unary_stream_service_description( + servicer.ReadRows, + gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadRowsRequest.FromString, + gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadRowsResponse.SerializeToString, + ), + "SampleRowKeys": utilities.unary_stream_service_description( + servicer.SampleRowKeys, + gcloud.bigtable._generated.bigtable_service_messages_pb2.SampleRowKeysRequest.FromString, + gcloud.bigtable._generated.bigtable_service_messages_pb2.SampleRowKeysResponse.SerializeToString, + ), + } + return implementations.server("google.bigtable.v1.BigtableService", method_service_descriptions, port, private_key=private_key, certificate_chain=certificate_chain) +def early_adopter_create_BigtableService_stub(host, port, metadata_transformer=None, secure=False, root_certificates=None, private_key=None, certificate_chain=None, server_host_override=None): + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_data_pb2 + method_invocation_descriptions = { + "CheckAndMutateRow": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_service_messages_pb2.CheckAndMutateRowRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_service_messages_pb2.CheckAndMutateRowResponse.FromString, + ), + "MutateRow": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_service_messages_pb2.MutateRowRequest.SerializeToString, + gcloud.bigtable._generated.empty_pb2.Empty.FromString, + ), + "ReadModifyWriteRow": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadModifyWriteRowRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_data_pb2.Row.FromString, + ), + "ReadRows": utilities.unary_stream_invocation_description( + gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadRowsRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_service_messages_pb2.ReadRowsResponse.FromString, + ), + "SampleRowKeys": utilities.unary_stream_invocation_description( + gcloud.bigtable._generated.bigtable_service_messages_pb2.SampleRowKeysRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_service_messages_pb2.SampleRowKeysResponse.FromString, + ), + } + return implementations.stub("google.bigtable.v1.BigtableService", method_invocation_descriptions, host, port, metadata_transformer=metadata_transformer, secure=secure, root_certificates=root_certificates, private_key=private_key, certificate_chain=certificate_chain, server_host_override=server_host_override) +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/bigtable_table_data_pb2.py b/gcloud/bigtable/_generated/bigtable_table_data_pb2.py new file mode 100644 index 000000000000..be67f19521cc --- /dev/null +++ b/gcloud/bigtable/_generated/bigtable_table_data_pb2.py @@ -0,0 +1,382 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/bigtable/admin/table/v1/bigtable_table_data.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import operations_pb2 as google_dot_longrunning_dot_operations__pb2 +from gcloud.bigtable._generated import duration_pb2 as google_dot_protobuf_dot_duration__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/bigtable/admin/table/v1/bigtable_table_data.proto', + package='google.bigtable.admin.table.v1', + syntax='proto3', + serialized_pb=_b('\n8google/bigtable/admin/table/v1/bigtable_table_data.proto\x12\x1egoogle.bigtable.admin.table.v1\x1a#google/longrunning/operations.proto\x1a\x1egoogle/protobuf/duration.proto\"\xfd\x02\n\x05Table\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x38\n\x11\x63urrent_operation\x18\x02 \x01(\x0b\x32\x1d.google.longrunning.Operation\x12R\n\x0f\x63olumn_families\x18\x03 \x03(\x0b\x32\x39.google.bigtable.admin.table.v1.Table.ColumnFamiliesEntry\x12O\n\x0bgranularity\x18\x04 \x01(\x0e\x32:.google.bigtable.admin.table.v1.Table.TimestampGranularity\x1a\x63\n\x13\x43olumnFamiliesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12;\n\x05value\x18\x02 \x01(\x0b\x32,.google.bigtable.admin.table.v1.ColumnFamily:\x02\x38\x01\"\"\n\x14TimestampGranularity\x12\n\n\x06MILLIS\x10\x00\"l\n\x0c\x43olumnFamily\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x15\n\rgc_expression\x18\x02 \x01(\t\x12\x37\n\x07gc_rule\x18\x03 \x01(\x0b\x32&.google.bigtable.admin.table.v1.GcRule\"\xed\x02\n\x06GcRule\x12\x1a\n\x10max_num_versions\x18\x01 \x01(\x05H\x00\x12,\n\x07max_age\x18\x02 \x01(\x0b\x32\x19.google.protobuf.DurationH\x00\x12K\n\x0cintersection\x18\x03 \x01(\x0b\x32\x33.google.bigtable.admin.table.v1.GcRule.IntersectionH\x00\x12=\n\x05union\x18\x04 \x01(\x0b\x32,.google.bigtable.admin.table.v1.GcRule.UnionH\x00\x1a\x45\n\x0cIntersection\x12\x35\n\x05rules\x18\x01 \x03(\x0b\x32&.google.bigtable.admin.table.v1.GcRule\x1a>\n\x05Union\x12\x35\n\x05rules\x18\x01 \x03(\x0b\x32&.google.bigtable.admin.table.v1.GcRuleB\x06\n\x04ruleB>\n\"com.google.bigtable.admin.table.v1B\x16\x42igtableTableDataProtoP\x01\x62\x06proto3') + , + dependencies=[google_dot_longrunning_dot_operations__pb2.DESCRIPTOR,google_dot_protobuf_dot_duration__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + +_TABLE_TIMESTAMPGRANULARITY = _descriptor.EnumDescriptor( + name='TimestampGranularity', + full_name='google.bigtable.admin.table.v1.Table.TimestampGranularity', + filename=None, + file=DESCRIPTOR, + values=[ + _descriptor.EnumValueDescriptor( + name='MILLIS', index=0, number=0, + options=None, + type=None), + ], + containing_type=None, + options=None, + serialized_start=509, + serialized_end=543, +) +_sym_db.RegisterEnumDescriptor(_TABLE_TIMESTAMPGRANULARITY) + + +_TABLE_COLUMNFAMILIESENTRY = _descriptor.Descriptor( + name='ColumnFamiliesEntry', + full_name='google.bigtable.admin.table.v1.Table.ColumnFamiliesEntry', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='key', full_name='google.bigtable.admin.table.v1.Table.ColumnFamiliesEntry.key', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='value', full_name='google.bigtable.admin.table.v1.Table.ColumnFamiliesEntry.value', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=_descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')), + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=408, + serialized_end=507, +) + +_TABLE = _descriptor.Descriptor( + name='Table', + full_name='google.bigtable.admin.table.v1.Table', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.Table.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='current_operation', full_name='google.bigtable.admin.table.v1.Table.current_operation', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='column_families', full_name='google.bigtable.admin.table.v1.Table.column_families', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='granularity', full_name='google.bigtable.admin.table.v1.Table.granularity', index=3, + number=4, type=14, cpp_type=8, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_TABLE_COLUMNFAMILIESENTRY, ], + enum_types=[ + _TABLE_TIMESTAMPGRANULARITY, + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=162, + serialized_end=543, +) + + +_COLUMNFAMILY = _descriptor.Descriptor( + name='ColumnFamily', + full_name='google.bigtable.admin.table.v1.ColumnFamily', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.ColumnFamily.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='gc_expression', full_name='google.bigtable.admin.table.v1.ColumnFamily.gc_expression', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='gc_rule', full_name='google.bigtable.admin.table.v1.ColumnFamily.gc_rule', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=545, + serialized_end=653, +) + + +_GCRULE_INTERSECTION = _descriptor.Descriptor( + name='Intersection', + full_name='google.bigtable.admin.table.v1.GcRule.Intersection', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='rules', full_name='google.bigtable.admin.table.v1.GcRule.Intersection.rules', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=880, + serialized_end=949, +) + +_GCRULE_UNION = _descriptor.Descriptor( + name='Union', + full_name='google.bigtable.admin.table.v1.GcRule.Union', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='rules', full_name='google.bigtable.admin.table.v1.GcRule.Union.rules', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=951, + serialized_end=1013, +) + +_GCRULE = _descriptor.Descriptor( + name='GcRule', + full_name='google.bigtable.admin.table.v1.GcRule', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='max_num_versions', full_name='google.bigtable.admin.table.v1.GcRule.max_num_versions', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='max_age', full_name='google.bigtable.admin.table.v1.GcRule.max_age', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='intersection', full_name='google.bigtable.admin.table.v1.GcRule.intersection', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='union', full_name='google.bigtable.admin.table.v1.GcRule.union', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[_GCRULE_INTERSECTION, _GCRULE_UNION, ], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='rule', full_name='google.bigtable.admin.table.v1.GcRule.rule', + index=0, containing_type=None, fields=[]), + ], + serialized_start=656, + serialized_end=1021, +) + +_TABLE_COLUMNFAMILIESENTRY.fields_by_name['value'].message_type = _COLUMNFAMILY +_TABLE_COLUMNFAMILIESENTRY.containing_type = _TABLE +_TABLE.fields_by_name['current_operation'].message_type = google_dot_longrunning_dot_operations__pb2._OPERATION +_TABLE.fields_by_name['column_families'].message_type = _TABLE_COLUMNFAMILIESENTRY +_TABLE.fields_by_name['granularity'].enum_type = _TABLE_TIMESTAMPGRANULARITY +_TABLE_TIMESTAMPGRANULARITY.containing_type = _TABLE +_COLUMNFAMILY.fields_by_name['gc_rule'].message_type = _GCRULE +_GCRULE_INTERSECTION.fields_by_name['rules'].message_type = _GCRULE +_GCRULE_INTERSECTION.containing_type = _GCRULE +_GCRULE_UNION.fields_by_name['rules'].message_type = _GCRULE +_GCRULE_UNION.containing_type = _GCRULE +_GCRULE.fields_by_name['max_age'].message_type = google_dot_protobuf_dot_duration__pb2._DURATION +_GCRULE.fields_by_name['intersection'].message_type = _GCRULE_INTERSECTION +_GCRULE.fields_by_name['union'].message_type = _GCRULE_UNION +_GCRULE.oneofs_by_name['rule'].fields.append( + _GCRULE.fields_by_name['max_num_versions']) +_GCRULE.fields_by_name['max_num_versions'].containing_oneof = _GCRULE.oneofs_by_name['rule'] +_GCRULE.oneofs_by_name['rule'].fields.append( + _GCRULE.fields_by_name['max_age']) +_GCRULE.fields_by_name['max_age'].containing_oneof = _GCRULE.oneofs_by_name['rule'] +_GCRULE.oneofs_by_name['rule'].fields.append( + _GCRULE.fields_by_name['intersection']) +_GCRULE.fields_by_name['intersection'].containing_oneof = _GCRULE.oneofs_by_name['rule'] +_GCRULE.oneofs_by_name['rule'].fields.append( + _GCRULE.fields_by_name['union']) +_GCRULE.fields_by_name['union'].containing_oneof = _GCRULE.oneofs_by_name['rule'] +DESCRIPTOR.message_types_by_name['Table'] = _TABLE +DESCRIPTOR.message_types_by_name['ColumnFamily'] = _COLUMNFAMILY +DESCRIPTOR.message_types_by_name['GcRule'] = _GCRULE + +Table = _reflection.GeneratedProtocolMessageType('Table', (_message.Message,), dict( + + ColumnFamiliesEntry = _reflection.GeneratedProtocolMessageType('ColumnFamiliesEntry', (_message.Message,), dict( + DESCRIPTOR = _TABLE_COLUMNFAMILIESENTRY, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.Table.ColumnFamiliesEntry) + )) + , + DESCRIPTOR = _TABLE, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.Table) + )) +_sym_db.RegisterMessage(Table) +_sym_db.RegisterMessage(Table.ColumnFamiliesEntry) + +ColumnFamily = _reflection.GeneratedProtocolMessageType('ColumnFamily', (_message.Message,), dict( + DESCRIPTOR = _COLUMNFAMILY, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.ColumnFamily) + )) +_sym_db.RegisterMessage(ColumnFamily) + +GcRule = _reflection.GeneratedProtocolMessageType('GcRule', (_message.Message,), dict( + + Intersection = _reflection.GeneratedProtocolMessageType('Intersection', (_message.Message,), dict( + DESCRIPTOR = _GCRULE_INTERSECTION, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.GcRule.Intersection) + )) + , + + Union = _reflection.GeneratedProtocolMessageType('Union', (_message.Message,), dict( + DESCRIPTOR = _GCRULE_UNION, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.GcRule.Union) + )) + , + DESCRIPTOR = _GCRULE, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_data_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.GcRule) + )) +_sym_db.RegisterMessage(GcRule) +_sym_db.RegisterMessage(GcRule.Intersection) +_sym_db.RegisterMessage(GcRule.Union) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\"com.google.bigtable.admin.table.v1B\026BigtableTableDataProtoP\001')) +_TABLE_COLUMNFAMILIESENTRY.has_options = True +_TABLE_COLUMNFAMILIESENTRY._options = _descriptor._ParseOptions(descriptor_pb2.MessageOptions(), _b('8\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/bigtable_table_service_messages_pb2.py b/gcloud/bigtable/_generated/bigtable_table_service_messages_pb2.py new file mode 100644 index 000000000000..237976a2c02f --- /dev/null +++ b/gcloud/bigtable/_generated/bigtable_table_service_messages_pb2.py @@ -0,0 +1,394 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/bigtable/admin/table/v1/bigtable_table_service_messages.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import bigtable_table_data_pb2 as google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__data__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/bigtable/admin/table/v1/bigtable_table_service_messages.proto', + package='google.bigtable.admin.table.v1', + syntax='proto3', + serialized_pb=_b('\nDgoogle/bigtable/admin/table/v1/bigtable_table_service_messages.proto\x12\x1egoogle.bigtable.admin.table.v1\x1a\x38google/bigtable/admin/table/v1/bigtable_table_data.proto\"\x86\x01\n\x12\x43reateTableRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x10\n\x08table_id\x18\x02 \x01(\t\x12\x34\n\x05table\x18\x03 \x01(\x0b\x32%.google.bigtable.admin.table.v1.Table\x12\x1a\n\x12initial_split_keys\x18\x04 \x03(\t\"!\n\x11ListTablesRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"K\n\x12ListTablesResponse\x12\x35\n\x06tables\x18\x01 \x03(\x0b\x32%.google.bigtable.admin.table.v1.Table\"\x1f\n\x0fGetTableRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"\"\n\x12\x44\x65leteTableRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"2\n\x12RenameTableRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0e\n\x06new_id\x18\x02 \x01(\t\"\x88\x01\n\x19\x43reateColumnFamilyRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x18\n\x10\x63olumn_family_id\x18\x02 \x01(\t\x12\x43\n\rcolumn_family\x18\x03 \x01(\x0b\x32,.google.bigtable.admin.table.v1.ColumnFamily\")\n\x19\x44\x65leteColumnFamilyRequest\x12\x0c\n\x04name\x18\x01 \x01(\tBI\n\"com.google.bigtable.admin.table.v1B!BigtableTableServiceMessagesProtoP\x01\x62\x06proto3') + , + dependencies=[google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__data__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_CREATETABLEREQUEST = _descriptor.Descriptor( + name='CreateTableRequest', + full_name='google.bigtable.admin.table.v1.CreateTableRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.CreateTableRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='table_id', full_name='google.bigtable.admin.table.v1.CreateTableRequest.table_id', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='table', full_name='google.bigtable.admin.table.v1.CreateTableRequest.table', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='initial_split_keys', full_name='google.bigtable.admin.table.v1.CreateTableRequest.initial_split_keys', index=3, + number=4, type=9, cpp_type=9, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=163, + serialized_end=297, +) + + +_LISTTABLESREQUEST = _descriptor.Descriptor( + name='ListTablesRequest', + full_name='google.bigtable.admin.table.v1.ListTablesRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.ListTablesRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=299, + serialized_end=332, +) + + +_LISTTABLESRESPONSE = _descriptor.Descriptor( + name='ListTablesResponse', + full_name='google.bigtable.admin.table.v1.ListTablesResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='tables', full_name='google.bigtable.admin.table.v1.ListTablesResponse.tables', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=334, + serialized_end=409, +) + + +_GETTABLEREQUEST = _descriptor.Descriptor( + name='GetTableRequest', + full_name='google.bigtable.admin.table.v1.GetTableRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.GetTableRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=411, + serialized_end=442, +) + + +_DELETETABLEREQUEST = _descriptor.Descriptor( + name='DeleteTableRequest', + full_name='google.bigtable.admin.table.v1.DeleteTableRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.DeleteTableRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=444, + serialized_end=478, +) + + +_RENAMETABLEREQUEST = _descriptor.Descriptor( + name='RenameTableRequest', + full_name='google.bigtable.admin.table.v1.RenameTableRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.RenameTableRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='new_id', full_name='google.bigtable.admin.table.v1.RenameTableRequest.new_id', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=480, + serialized_end=530, +) + + +_CREATECOLUMNFAMILYREQUEST = _descriptor.Descriptor( + name='CreateColumnFamilyRequest', + full_name='google.bigtable.admin.table.v1.CreateColumnFamilyRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.CreateColumnFamilyRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='column_family_id', full_name='google.bigtable.admin.table.v1.CreateColumnFamilyRequest.column_family_id', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='column_family', full_name='google.bigtable.admin.table.v1.CreateColumnFamilyRequest.column_family', index=2, + number=3, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=533, + serialized_end=669, +) + + +_DELETECOLUMNFAMILYREQUEST = _descriptor.Descriptor( + name='DeleteColumnFamilyRequest', + full_name='google.bigtable.admin.table.v1.DeleteColumnFamilyRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.bigtable.admin.table.v1.DeleteColumnFamilyRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=671, + serialized_end=712, +) + +_CREATETABLEREQUEST.fields_by_name['table'].message_type = google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__data__pb2._TABLE +_LISTTABLESRESPONSE.fields_by_name['tables'].message_type = google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__data__pb2._TABLE +_CREATECOLUMNFAMILYREQUEST.fields_by_name['column_family'].message_type = google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__data__pb2._COLUMNFAMILY +DESCRIPTOR.message_types_by_name['CreateTableRequest'] = _CREATETABLEREQUEST +DESCRIPTOR.message_types_by_name['ListTablesRequest'] = _LISTTABLESREQUEST +DESCRIPTOR.message_types_by_name['ListTablesResponse'] = _LISTTABLESRESPONSE +DESCRIPTOR.message_types_by_name['GetTableRequest'] = _GETTABLEREQUEST +DESCRIPTOR.message_types_by_name['DeleteTableRequest'] = _DELETETABLEREQUEST +DESCRIPTOR.message_types_by_name['RenameTableRequest'] = _RENAMETABLEREQUEST +DESCRIPTOR.message_types_by_name['CreateColumnFamilyRequest'] = _CREATECOLUMNFAMILYREQUEST +DESCRIPTOR.message_types_by_name['DeleteColumnFamilyRequest'] = _DELETECOLUMNFAMILYREQUEST + +CreateTableRequest = _reflection.GeneratedProtocolMessageType('CreateTableRequest', (_message.Message,), dict( + DESCRIPTOR = _CREATETABLEREQUEST, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.CreateTableRequest) + )) +_sym_db.RegisterMessage(CreateTableRequest) + +ListTablesRequest = _reflection.GeneratedProtocolMessageType('ListTablesRequest', (_message.Message,), dict( + DESCRIPTOR = _LISTTABLESREQUEST, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.ListTablesRequest) + )) +_sym_db.RegisterMessage(ListTablesRequest) + +ListTablesResponse = _reflection.GeneratedProtocolMessageType('ListTablesResponse', (_message.Message,), dict( + DESCRIPTOR = _LISTTABLESRESPONSE, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.ListTablesResponse) + )) +_sym_db.RegisterMessage(ListTablesResponse) + +GetTableRequest = _reflection.GeneratedProtocolMessageType('GetTableRequest', (_message.Message,), dict( + DESCRIPTOR = _GETTABLEREQUEST, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.GetTableRequest) + )) +_sym_db.RegisterMessage(GetTableRequest) + +DeleteTableRequest = _reflection.GeneratedProtocolMessageType('DeleteTableRequest', (_message.Message,), dict( + DESCRIPTOR = _DELETETABLEREQUEST, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.DeleteTableRequest) + )) +_sym_db.RegisterMessage(DeleteTableRequest) + +RenameTableRequest = _reflection.GeneratedProtocolMessageType('RenameTableRequest', (_message.Message,), dict( + DESCRIPTOR = _RENAMETABLEREQUEST, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.RenameTableRequest) + )) +_sym_db.RegisterMessage(RenameTableRequest) + +CreateColumnFamilyRequest = _reflection.GeneratedProtocolMessageType('CreateColumnFamilyRequest', (_message.Message,), dict( + DESCRIPTOR = _CREATECOLUMNFAMILYREQUEST, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.CreateColumnFamilyRequest) + )) +_sym_db.RegisterMessage(CreateColumnFamilyRequest) + +DeleteColumnFamilyRequest = _reflection.GeneratedProtocolMessageType('DeleteColumnFamilyRequest', (_message.Message,), dict( + DESCRIPTOR = _DELETECOLUMNFAMILYREQUEST, + __module__ = 'google.bigtable.admin.table.v1.bigtable_table_service_messages_pb2' + # @@protoc_insertion_point(class_scope:google.bigtable.admin.table.v1.DeleteColumnFamilyRequest) + )) +_sym_db.RegisterMessage(DeleteColumnFamilyRequest) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\"com.google.bigtable.admin.table.v1B!BigtableTableServiceMessagesProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/bigtable_table_service_pb2.py b/gcloud/bigtable/_generated/bigtable_table_service_pb2.py new file mode 100644 index 000000000000..a75a1e5e6cb1 --- /dev/null +++ b/gcloud/bigtable/_generated/bigtable_table_service_pb2.py @@ -0,0 +1,223 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/bigtable/admin/table/v1/bigtable_table_service.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from gcloud.bigtable._generated import bigtable_table_data_pb2 as google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__data__pb2 +from gcloud.bigtable._generated import bigtable_table_service_messages_pb2 as google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__service__messages__pb2 +from gcloud.bigtable._generated import empty_pb2 as google_dot_protobuf_dot_empty__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/bigtable/admin/table/v1/bigtable_table_service.proto', + package='google.bigtable.admin.table.v1', + syntax='proto3', + serialized_pb=_b('\n;google/bigtable/admin/table/v1/bigtable_table_service.proto\x12\x1egoogle.bigtable.admin.table.v1\x1a\x1cgoogle/api/annotations.proto\x1a\x38google/bigtable/admin/table/v1/bigtable_table_data.proto\x1a\x44google/bigtable/admin/table/v1/bigtable_table_service_messages.proto\x1a\x1bgoogle/protobuf/empty.proto2\x89\x0b\n\x14\x42igtableTableService\x12\xa4\x01\n\x0b\x43reateTable\x12\x32.google.bigtable.admin.table.v1.CreateTableRequest\x1a%.google.bigtable.admin.table.v1.Table\":\x82\xd3\xe4\x93\x02\x34\"//v1/{name=projects/*/zones/*/clusters/*}/tables:\x01*\x12\xac\x01\n\nListTables\x12\x31.google.bigtable.admin.table.v1.ListTablesRequest\x1a\x32.google.bigtable.admin.table.v1.ListTablesResponse\"7\x82\xd3\xe4\x93\x02\x31\x12//v1/{name=projects/*/zones/*/clusters/*}/tables\x12\x9d\x01\n\x08GetTable\x12/.google.bigtable.admin.table.v1.GetTableRequest\x1a%.google.bigtable.admin.table.v1.Table\"9\x82\xd3\xe4\x93\x02\x33\x12\x31/v1/{name=projects/*/zones/*/clusters/*/tables/*}\x12\x94\x01\n\x0b\x44\x65leteTable\x12\x32.google.bigtable.admin.table.v1.DeleteTableRequest\x1a\x16.google.protobuf.Empty\"9\x82\xd3\xe4\x93\x02\x33*1/v1/{name=projects/*/zones/*/clusters/*/tables/*}\x12\x9e\x01\n\x0bRenameTable\x12\x32.google.bigtable.admin.table.v1.RenameTableRequest\x1a\x16.google.protobuf.Empty\"C\x82\xd3\xe4\x93\x02=\"8/v1/{name=projects/*/zones/*/clusters/*/tables/*}:rename:\x01*\x12\xca\x01\n\x12\x43reateColumnFamily\x12\x39.google.bigtable.admin.table.v1.CreateColumnFamilyRequest\x1a,.google.bigtable.admin.table.v1.ColumnFamily\"K\x82\xd3\xe4\x93\x02\x45\"@/v1/{name=projects/*/zones/*/clusters/*/tables/*}/columnFamilies:\x01*\x12\xbf\x01\n\x12UpdateColumnFamily\x12,.google.bigtable.admin.table.v1.ColumnFamily\x1a,.google.bigtable.admin.table.v1.ColumnFamily\"M\x82\xd3\xe4\x93\x02G\x1a\x42/v1/{name=projects/*/zones/*/clusters/*/tables/*/columnFamilies/*}:\x01*\x12\xb3\x01\n\x12\x44\x65leteColumnFamily\x12\x39.google.bigtable.admin.table.v1.DeleteColumnFamilyRequest\x1a\x16.google.protobuf.Empty\"J\x82\xd3\xe4\x93\x02\x44*B/v1/{name=projects/*/zones/*/clusters/*/tables/*/columnFamilies/*}BB\n\"com.google.bigtable.admin.table.v1B\x1a\x42igtableTableServicesProtoP\x01\x62\x06proto3') + , + dependencies=[google_dot_api_dot_annotations__pb2.DESCRIPTOR,google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__data__pb2.DESCRIPTOR,google_dot_bigtable_dot_admin_dot_table_dot_v1_dot_bigtable__table__service__messages__pb2.DESCRIPTOR,google_dot_protobuf_dot_empty__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\"com.google.bigtable.admin.table.v1B\032BigtableTableServicesProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +class EarlyAdopterBigtableTableServiceServicer(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def CreateTable(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def ListTables(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def GetTable(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def DeleteTable(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def RenameTable(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def CreateColumnFamily(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def UpdateColumnFamily(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def DeleteColumnFamily(self, request, context): + raise NotImplementedError() +class EarlyAdopterBigtableTableServiceServer(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def start(self): + raise NotImplementedError() + @abc.abstractmethod + def stop(self): + raise NotImplementedError() +class EarlyAdopterBigtableTableServiceStub(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def CreateTable(self, request): + raise NotImplementedError() + CreateTable.async = None + @abc.abstractmethod + def ListTables(self, request): + raise NotImplementedError() + ListTables.async = None + @abc.abstractmethod + def GetTable(self, request): + raise NotImplementedError() + GetTable.async = None + @abc.abstractmethod + def DeleteTable(self, request): + raise NotImplementedError() + DeleteTable.async = None + @abc.abstractmethod + def RenameTable(self, request): + raise NotImplementedError() + RenameTable.async = None + @abc.abstractmethod + def CreateColumnFamily(self, request): + raise NotImplementedError() + CreateColumnFamily.async = None + @abc.abstractmethod + def UpdateColumnFamily(self, request): + raise NotImplementedError() + UpdateColumnFamily.async = None + @abc.abstractmethod + def DeleteColumnFamily(self, request): + raise NotImplementedError() + DeleteColumnFamily.async = None +def early_adopter_create_BigtableTableService_server(servicer, port, private_key=None, certificate_chain=None): + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + method_service_descriptions = { + "CreateColumnFamily": utilities.unary_unary_service_description( + servicer.CreateColumnFamily, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.CreateColumnFamilyRequest.FromString, + gcloud.bigtable._generated.bigtable_table_data_pb2.ColumnFamily.SerializeToString, + ), + "CreateTable": utilities.unary_unary_service_description( + servicer.CreateTable, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.CreateTableRequest.FromString, + gcloud.bigtable._generated.bigtable_table_data_pb2.Table.SerializeToString, + ), + "DeleteColumnFamily": utilities.unary_unary_service_description( + servicer.DeleteColumnFamily, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.DeleteColumnFamilyRequest.FromString, + gcloud.bigtable._generated.empty_pb2.Empty.SerializeToString, + ), + "DeleteTable": utilities.unary_unary_service_description( + servicer.DeleteTable, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.DeleteTableRequest.FromString, + gcloud.bigtable._generated.empty_pb2.Empty.SerializeToString, + ), + "GetTable": utilities.unary_unary_service_description( + servicer.GetTable, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.GetTableRequest.FromString, + gcloud.bigtable._generated.bigtable_table_data_pb2.Table.SerializeToString, + ), + "ListTables": utilities.unary_unary_service_description( + servicer.ListTables, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.ListTablesRequest.FromString, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.ListTablesResponse.SerializeToString, + ), + "RenameTable": utilities.unary_unary_service_description( + servicer.RenameTable, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.RenameTableRequest.FromString, + gcloud.bigtable._generated.empty_pb2.Empty.SerializeToString, + ), + "UpdateColumnFamily": utilities.unary_unary_service_description( + servicer.UpdateColumnFamily, + gcloud.bigtable._generated.bigtable_table_data_pb2.ColumnFamily.FromString, + gcloud.bigtable._generated.bigtable_table_data_pb2.ColumnFamily.SerializeToString, + ), + } + return implementations.server("google.bigtable.admin.table.v1.BigtableTableService", method_service_descriptions, port, private_key=private_key, certificate_chain=certificate_chain) +def early_adopter_create_BigtableTableService_stub(host, port, metadata_transformer=None, secure=False, root_certificates=None, private_key=None, certificate_chain=None, server_host_override=None): + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_data_pb2 + import gcloud.bigtable._generated.bigtable_table_service_messages_pb2 + import gcloud.bigtable._generated.empty_pb2 + method_invocation_descriptions = { + "CreateColumnFamily": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.CreateColumnFamilyRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_table_data_pb2.ColumnFamily.FromString, + ), + "CreateTable": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.CreateTableRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_table_data_pb2.Table.FromString, + ), + "DeleteColumnFamily": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.DeleteColumnFamilyRequest.SerializeToString, + gcloud.bigtable._generated.empty_pb2.Empty.FromString, + ), + "DeleteTable": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.DeleteTableRequest.SerializeToString, + gcloud.bigtable._generated.empty_pb2.Empty.FromString, + ), + "GetTable": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.GetTableRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_table_data_pb2.Table.FromString, + ), + "ListTables": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.ListTablesRequest.SerializeToString, + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.ListTablesResponse.FromString, + ), + "RenameTable": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_table_service_messages_pb2.RenameTableRequest.SerializeToString, + gcloud.bigtable._generated.empty_pb2.Empty.FromString, + ), + "UpdateColumnFamily": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.bigtable_table_data_pb2.ColumnFamily.SerializeToString, + gcloud.bigtable._generated.bigtable_table_data_pb2.ColumnFamily.FromString, + ), + } + return implementations.stub("google.bigtable.admin.table.v1.BigtableTableService", method_invocation_descriptions, host, port, metadata_transformer=metadata_transformer, secure=secure, root_certificates=root_certificates, private_key=private_key, certificate_chain=certificate_chain, server_host_override=server_host_override) +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/duration_pb2.py b/gcloud/bigtable/_generated/duration_pb2.py new file mode 100644 index 000000000000..7be5b3cdb13a --- /dev/null +++ b/gcloud/bigtable/_generated/duration_pb2.py @@ -0,0 +1,81 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/protobuf/duration.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/protobuf/duration.proto', + package='google.protobuf', + syntax='proto3', + serialized_pb=_b('\n\x1egoogle/protobuf/duration.proto\x12\x0fgoogle.protobuf\"*\n\x08\x44uration\x12\x0f\n\x07seconds\x18\x01 \x01(\x03\x12\r\n\x05nanos\x18\x02 \x01(\x05\x42)\n\x13\x63om.google.protobufB\rDurationProtoP\x01\xa0\x01\x01\x62\x06proto3') +) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_DURATION = _descriptor.Descriptor( + name='Duration', + full_name='google.protobuf.Duration', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='seconds', full_name='google.protobuf.Duration.seconds', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='nanos', full_name='google.protobuf.Duration.nanos', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=51, + serialized_end=93, +) + +DESCRIPTOR.message_types_by_name['Duration'] = _DURATION + +Duration = _reflection.GeneratedProtocolMessageType('Duration', (_message.Message,), dict( + DESCRIPTOR = _DURATION, + __module__ = 'google.protobuf.duration_pb2' + # @@protoc_insertion_point(class_scope:google.protobuf.Duration) + )) +_sym_db.RegisterMessage(Duration) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\023com.google.protobufB\rDurationProtoP\001\240\001\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/empty_pb2.py b/gcloud/bigtable/_generated/empty_pb2.py new file mode 100644 index 000000000000..976dfb91869d --- /dev/null +++ b/gcloud/bigtable/_generated/empty_pb2.py @@ -0,0 +1,67 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/protobuf/empty.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/protobuf/empty.proto', + package='google.protobuf', + syntax='proto3', + serialized_pb=_b('\n\x1bgoogle/protobuf/empty.proto\x12\x0fgoogle.protobuf\"\x07\n\x05\x45mptyB#\n\x13\x63om.google.protobufB\nEmptyProtoP\x01\x62\x06proto3') +) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_EMPTY = _descriptor.Descriptor( + name='Empty', + full_name='google.protobuf.Empty', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=48, + serialized_end=55, +) + +DESCRIPTOR.message_types_by_name['Empty'] = _EMPTY + +Empty = _reflection.GeneratedProtocolMessageType('Empty', (_message.Message,), dict( + DESCRIPTOR = _EMPTY, + __module__ = 'google.protobuf.empty_pb2' + # @@protoc_insertion_point(class_scope:google.protobuf.Empty) + )) +_sym_db.RegisterMessage(Empty) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\023com.google.protobufB\nEmptyProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/http_pb2.py b/gcloud/bigtable/_generated/http_pb2.py new file mode 100644 index 000000000000..f755e4ce1bb1 --- /dev/null +++ b/gcloud/bigtable/_generated/http_pb2.py @@ -0,0 +1,192 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/api/http.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/api/http.proto', + package='google.api', + syntax='proto3', + serialized_pb=_b('\n\x15google/api/http.proto\x12\ngoogle.api\"\xd8\x01\n\x08HttpRule\x12\r\n\x03get\x18\x02 \x01(\tH\x00\x12\r\n\x03put\x18\x03 \x01(\tH\x00\x12\x0e\n\x04post\x18\x04 \x01(\tH\x00\x12\x10\n\x06\x64\x65lete\x18\x05 \x01(\tH\x00\x12\x0f\n\x05patch\x18\x06 \x01(\tH\x00\x12/\n\x06\x63ustom\x18\x08 \x01(\x0b\x32\x1d.google.api.CustomHttpPatternH\x00\x12\x0c\n\x04\x62ody\x18\x07 \x01(\t\x12\x31\n\x13\x61\x64\x64itional_bindings\x18\x0b \x03(\x0b\x32\x14.google.api.HttpRuleB\t\n\x07pattern\"/\n\x11\x43ustomHttpPattern\x12\x0c\n\x04kind\x18\x01 \x01(\t\x12\x0c\n\x04path\x18\x02 \x01(\tB\x1d\n\x0e\x63om.google.apiB\tHttpProtoP\x01\x62\x06proto3') +) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_HTTPRULE = _descriptor.Descriptor( + name='HttpRule', + full_name='google.api.HttpRule', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='get', full_name='google.api.HttpRule.get', index=0, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='put', full_name='google.api.HttpRule.put', index=1, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='post', full_name='google.api.HttpRule.post', index=2, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='delete', full_name='google.api.HttpRule.delete', index=3, + number=5, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='patch', full_name='google.api.HttpRule.patch', index=4, + number=6, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='custom', full_name='google.api.HttpRule.custom', index=5, + number=8, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='body', full_name='google.api.HttpRule.body', index=6, + number=7, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='additional_bindings', full_name='google.api.HttpRule.additional_bindings', index=7, + number=11, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='pattern', full_name='google.api.HttpRule.pattern', + index=0, containing_type=None, fields=[]), + ], + serialized_start=38, + serialized_end=254, +) + + +_CUSTOMHTTPPATTERN = _descriptor.Descriptor( + name='CustomHttpPattern', + full_name='google.api.CustomHttpPattern', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='kind', full_name='google.api.CustomHttpPattern.kind', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='path', full_name='google.api.CustomHttpPattern.path', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=256, + serialized_end=303, +) + +_HTTPRULE.fields_by_name['custom'].message_type = _CUSTOMHTTPPATTERN +_HTTPRULE.fields_by_name['additional_bindings'].message_type = _HTTPRULE +_HTTPRULE.oneofs_by_name['pattern'].fields.append( + _HTTPRULE.fields_by_name['get']) +_HTTPRULE.fields_by_name['get'].containing_oneof = _HTTPRULE.oneofs_by_name['pattern'] +_HTTPRULE.oneofs_by_name['pattern'].fields.append( + _HTTPRULE.fields_by_name['put']) +_HTTPRULE.fields_by_name['put'].containing_oneof = _HTTPRULE.oneofs_by_name['pattern'] +_HTTPRULE.oneofs_by_name['pattern'].fields.append( + _HTTPRULE.fields_by_name['post']) +_HTTPRULE.fields_by_name['post'].containing_oneof = _HTTPRULE.oneofs_by_name['pattern'] +_HTTPRULE.oneofs_by_name['pattern'].fields.append( + _HTTPRULE.fields_by_name['delete']) +_HTTPRULE.fields_by_name['delete'].containing_oneof = _HTTPRULE.oneofs_by_name['pattern'] +_HTTPRULE.oneofs_by_name['pattern'].fields.append( + _HTTPRULE.fields_by_name['patch']) +_HTTPRULE.fields_by_name['patch'].containing_oneof = _HTTPRULE.oneofs_by_name['pattern'] +_HTTPRULE.oneofs_by_name['pattern'].fields.append( + _HTTPRULE.fields_by_name['custom']) +_HTTPRULE.fields_by_name['custom'].containing_oneof = _HTTPRULE.oneofs_by_name['pattern'] +DESCRIPTOR.message_types_by_name['HttpRule'] = _HTTPRULE +DESCRIPTOR.message_types_by_name['CustomHttpPattern'] = _CUSTOMHTTPPATTERN + +HttpRule = _reflection.GeneratedProtocolMessageType('HttpRule', (_message.Message,), dict( + DESCRIPTOR = _HTTPRULE, + __module__ = 'google.api.http_pb2' + # @@protoc_insertion_point(class_scope:google.api.HttpRule) + )) +_sym_db.RegisterMessage(HttpRule) + +CustomHttpPattern = _reflection.GeneratedProtocolMessageType('CustomHttpPattern', (_message.Message,), dict( + DESCRIPTOR = _CUSTOMHTTPPATTERN, + __module__ = 'google.api.http_pb2' + # @@protoc_insertion_point(class_scope:google.api.CustomHttpPattern) + )) +_sym_db.RegisterMessage(CustomHttpPattern) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\016com.google.apiB\tHttpProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/operations_pb2.py b/gcloud/bigtable/_generated/operations_pb2.py new file mode 100644 index 000000000000..54bfdb5c4485 --- /dev/null +++ b/gcloud/bigtable/_generated/operations_pb2.py @@ -0,0 +1,446 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/longrunning/operations.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import annotations_pb2 as google_dot_api_dot_annotations__pb2 +from gcloud.bigtable._generated import any_pb2 as google_dot_protobuf_dot_any__pb2 +from gcloud.bigtable._generated import empty_pb2 as google_dot_protobuf_dot_empty__pb2 +from gcloud.bigtable._generated import status_pb2 as google_dot_rpc_dot_status__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/longrunning/operations.proto', + package='google.longrunning', + syntax='proto3', + serialized_pb=_b('\n#google/longrunning/operations.proto\x12\x12google.longrunning\x1a\x1cgoogle/api/annotations.proto\x1a\x19google/protobuf/any.proto\x1a\x1bgoogle/protobuf/empty.proto\x1a\x17google/rpc/status.proto\"\xa8\x01\n\tOperation\x12\x0c\n\x04name\x18\x01 \x01(\t\x12&\n\x08metadata\x18\x02 \x01(\x0b\x32\x14.google.protobuf.Any\x12\x0c\n\x04\x64one\x18\x03 \x01(\x08\x12#\n\x05\x65rror\x18\x04 \x01(\x0b\x32\x12.google.rpc.StatusH\x00\x12(\n\x08response\x18\x05 \x01(\x0b\x32\x14.google.protobuf.AnyH\x00\x42\x08\n\x06result\"#\n\x13GetOperationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"\\\n\x15ListOperationsRequest\x12\x0c\n\x04name\x18\x04 \x01(\t\x12\x0e\n\x06\x66ilter\x18\x01 \x01(\t\x12\x11\n\tpage_size\x18\x02 \x01(\x05\x12\x12\n\npage_token\x18\x03 \x01(\t\"d\n\x16ListOperationsResponse\x12\x31\n\noperations\x18\x01 \x03(\x0b\x32\x1d.google.longrunning.Operation\x12\x17\n\x0fnext_page_token\x18\x02 \x01(\t\"&\n\x16\x43\x61ncelOperationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t\"&\n\x16\x44\x65leteOperationRequest\x12\x0c\n\x04name\x18\x01 \x01(\t2\x8c\x04\n\nOperations\x12x\n\x0cGetOperation\x12\'.google.longrunning.GetOperationRequest\x1a\x1d.google.longrunning.Operation\" \x82\xd3\xe4\x93\x02\x1a\x12\x18/v1/{name=operations/**}\x12\x86\x01\n\x0eListOperations\x12).google.longrunning.ListOperationsRequest\x1a*.google.longrunning.ListOperationsResponse\"\x1d\x82\xd3\xe4\x93\x02\x17\x12\x15/v1/{name=operations}\x12\x81\x01\n\x0f\x43\x61ncelOperation\x12*.google.longrunning.CancelOperationRequest\x1a\x16.google.protobuf.Empty\"*\x82\xd3\xe4\x93\x02$\"\x1f/v1/{name=operations/**}:cancel:\x01*\x12w\n\x0f\x44\x65leteOperation\x12*.google.longrunning.DeleteOperationRequest\x1a\x16.google.protobuf.Empty\" \x82\xd3\xe4\x93\x02\x1a*\x18/v1/{name=operations/**}B+\n\x16\x63om.google.longrunningB\x0fOperationsProtoP\x01\x62\x06proto3') + , + dependencies=[google_dot_api_dot_annotations__pb2.DESCRIPTOR,google_dot_protobuf_dot_any__pb2.DESCRIPTOR,google_dot_protobuf_dot_empty__pb2.DESCRIPTOR,google_dot_rpc_dot_status__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_OPERATION = _descriptor.Descriptor( + name='Operation', + full_name='google.longrunning.Operation', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.longrunning.Operation.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='metadata', full_name='google.longrunning.Operation.metadata', index=1, + number=2, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='done', full_name='google.longrunning.Operation.done', index=2, + number=3, type=8, cpp_type=7, label=1, + has_default_value=False, default_value=False, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='error', full_name='google.longrunning.Operation.error', index=3, + number=4, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='response', full_name='google.longrunning.Operation.response', index=4, + number=5, type=11, cpp_type=10, label=1, + has_default_value=False, default_value=None, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + _descriptor.OneofDescriptor( + name='result', full_name='google.longrunning.Operation.result', + index=0, containing_type=None, fields=[]), + ], + serialized_start=171, + serialized_end=339, +) + + +_GETOPERATIONREQUEST = _descriptor.Descriptor( + name='GetOperationRequest', + full_name='google.longrunning.GetOperationRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.longrunning.GetOperationRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=341, + serialized_end=376, +) + + +_LISTOPERATIONSREQUEST = _descriptor.Descriptor( + name='ListOperationsRequest', + full_name='google.longrunning.ListOperationsRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.longrunning.ListOperationsRequest.name', index=0, + number=4, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='filter', full_name='google.longrunning.ListOperationsRequest.filter', index=1, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='page_size', full_name='google.longrunning.ListOperationsRequest.page_size', index=2, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='page_token', full_name='google.longrunning.ListOperationsRequest.page_token', index=3, + number=3, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=378, + serialized_end=470, +) + + +_LISTOPERATIONSRESPONSE = _descriptor.Descriptor( + name='ListOperationsResponse', + full_name='google.longrunning.ListOperationsResponse', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='operations', full_name='google.longrunning.ListOperationsResponse.operations', index=0, + number=1, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='next_page_token', full_name='google.longrunning.ListOperationsResponse.next_page_token', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=472, + serialized_end=572, +) + + +_CANCELOPERATIONREQUEST = _descriptor.Descriptor( + name='CancelOperationRequest', + full_name='google.longrunning.CancelOperationRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.longrunning.CancelOperationRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=574, + serialized_end=612, +) + + +_DELETEOPERATIONREQUEST = _descriptor.Descriptor( + name='DeleteOperationRequest', + full_name='google.longrunning.DeleteOperationRequest', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='name', full_name='google.longrunning.DeleteOperationRequest.name', index=0, + number=1, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=614, + serialized_end=652, +) + +_OPERATION.fields_by_name['metadata'].message_type = google_dot_protobuf_dot_any__pb2._ANY +_OPERATION.fields_by_name['error'].message_type = google_dot_rpc_dot_status__pb2._STATUS +_OPERATION.fields_by_name['response'].message_type = google_dot_protobuf_dot_any__pb2._ANY +_OPERATION.oneofs_by_name['result'].fields.append( + _OPERATION.fields_by_name['error']) +_OPERATION.fields_by_name['error'].containing_oneof = _OPERATION.oneofs_by_name['result'] +_OPERATION.oneofs_by_name['result'].fields.append( + _OPERATION.fields_by_name['response']) +_OPERATION.fields_by_name['response'].containing_oneof = _OPERATION.oneofs_by_name['result'] +_LISTOPERATIONSRESPONSE.fields_by_name['operations'].message_type = _OPERATION +DESCRIPTOR.message_types_by_name['Operation'] = _OPERATION +DESCRIPTOR.message_types_by_name['GetOperationRequest'] = _GETOPERATIONREQUEST +DESCRIPTOR.message_types_by_name['ListOperationsRequest'] = _LISTOPERATIONSREQUEST +DESCRIPTOR.message_types_by_name['ListOperationsResponse'] = _LISTOPERATIONSRESPONSE +DESCRIPTOR.message_types_by_name['CancelOperationRequest'] = _CANCELOPERATIONREQUEST +DESCRIPTOR.message_types_by_name['DeleteOperationRequest'] = _DELETEOPERATIONREQUEST + +Operation = _reflection.GeneratedProtocolMessageType('Operation', (_message.Message,), dict( + DESCRIPTOR = _OPERATION, + __module__ = 'google.longrunning.operations_pb2' + # @@protoc_insertion_point(class_scope:google.longrunning.Operation) + )) +_sym_db.RegisterMessage(Operation) + +GetOperationRequest = _reflection.GeneratedProtocolMessageType('GetOperationRequest', (_message.Message,), dict( + DESCRIPTOR = _GETOPERATIONREQUEST, + __module__ = 'google.longrunning.operations_pb2' + # @@protoc_insertion_point(class_scope:google.longrunning.GetOperationRequest) + )) +_sym_db.RegisterMessage(GetOperationRequest) + +ListOperationsRequest = _reflection.GeneratedProtocolMessageType('ListOperationsRequest', (_message.Message,), dict( + DESCRIPTOR = _LISTOPERATIONSREQUEST, + __module__ = 'google.longrunning.operations_pb2' + # @@protoc_insertion_point(class_scope:google.longrunning.ListOperationsRequest) + )) +_sym_db.RegisterMessage(ListOperationsRequest) + +ListOperationsResponse = _reflection.GeneratedProtocolMessageType('ListOperationsResponse', (_message.Message,), dict( + DESCRIPTOR = _LISTOPERATIONSRESPONSE, + __module__ = 'google.longrunning.operations_pb2' + # @@protoc_insertion_point(class_scope:google.longrunning.ListOperationsResponse) + )) +_sym_db.RegisterMessage(ListOperationsResponse) + +CancelOperationRequest = _reflection.GeneratedProtocolMessageType('CancelOperationRequest', (_message.Message,), dict( + DESCRIPTOR = _CANCELOPERATIONREQUEST, + __module__ = 'google.longrunning.operations_pb2' + # @@protoc_insertion_point(class_scope:google.longrunning.CancelOperationRequest) + )) +_sym_db.RegisterMessage(CancelOperationRequest) + +DeleteOperationRequest = _reflection.GeneratedProtocolMessageType('DeleteOperationRequest', (_message.Message,), dict( + DESCRIPTOR = _DELETEOPERATIONREQUEST, + __module__ = 'google.longrunning.operations_pb2' + # @@protoc_insertion_point(class_scope:google.longrunning.DeleteOperationRequest) + )) +_sym_db.RegisterMessage(DeleteOperationRequest) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\026com.google.longrunningB\017OperationsProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +class EarlyAdopterOperationsServicer(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def GetOperation(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def ListOperations(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def CancelOperation(self, request, context): + raise NotImplementedError() + @abc.abstractmethod + def DeleteOperation(self, request, context): + raise NotImplementedError() +class EarlyAdopterOperationsServer(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def start(self): + raise NotImplementedError() + @abc.abstractmethod + def stop(self): + raise NotImplementedError() +class EarlyAdopterOperationsStub(object): + """""" + __metaclass__ = abc.ABCMeta + @abc.abstractmethod + def GetOperation(self, request): + raise NotImplementedError() + GetOperation.async = None + @abc.abstractmethod + def ListOperations(self, request): + raise NotImplementedError() + ListOperations.async = None + @abc.abstractmethod + def CancelOperation(self, request): + raise NotImplementedError() + CancelOperation.async = None + @abc.abstractmethod + def DeleteOperation(self, request): + raise NotImplementedError() + DeleteOperation.async = None +def early_adopter_create_Operations_server(servicer, port, private_key=None, certificate_chain=None): + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.empty_pb2 + method_service_descriptions = { + "CancelOperation": utilities.unary_unary_service_description( + servicer.CancelOperation, + gcloud.bigtable._generated.operations_pb2.CancelOperationRequest.FromString, + gcloud.bigtable._generated.empty_pb2.Empty.SerializeToString, + ), + "DeleteOperation": utilities.unary_unary_service_description( + servicer.DeleteOperation, + gcloud.bigtable._generated.operations_pb2.DeleteOperationRequest.FromString, + gcloud.bigtable._generated.empty_pb2.Empty.SerializeToString, + ), + "GetOperation": utilities.unary_unary_service_description( + servicer.GetOperation, + gcloud.bigtable._generated.operations_pb2.GetOperationRequest.FromString, + gcloud.bigtable._generated.operations_pb2.Operation.SerializeToString, + ), + "ListOperations": utilities.unary_unary_service_description( + servicer.ListOperations, + gcloud.bigtable._generated.operations_pb2.ListOperationsRequest.FromString, + gcloud.bigtable._generated.operations_pb2.ListOperationsResponse.SerializeToString, + ), + } + return implementations.server("google.longrunning.Operations", method_service_descriptions, port, private_key=private_key, certificate_chain=certificate_chain) +def early_adopter_create_Operations_stub(host, port, metadata_transformer=None, secure=False, root_certificates=None, private_key=None, certificate_chain=None, server_host_override=None): + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.empty_pb2 + import gcloud.bigtable._generated.operations_pb2 + import gcloud.bigtable._generated.empty_pb2 + method_invocation_descriptions = { + "CancelOperation": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.operations_pb2.CancelOperationRequest.SerializeToString, + gcloud.bigtable._generated.empty_pb2.Empty.FromString, + ), + "DeleteOperation": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.operations_pb2.DeleteOperationRequest.SerializeToString, + gcloud.bigtable._generated.empty_pb2.Empty.FromString, + ), + "GetOperation": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.operations_pb2.GetOperationRequest.SerializeToString, + gcloud.bigtable._generated.operations_pb2.Operation.FromString, + ), + "ListOperations": utilities.unary_unary_invocation_description( + gcloud.bigtable._generated.operations_pb2.ListOperationsRequest.SerializeToString, + gcloud.bigtable._generated.operations_pb2.ListOperationsResponse.FromString, + ), + } + return implementations.stub("google.longrunning.Operations", method_invocation_descriptions, host, port, metadata_transformer=metadata_transformer, secure=secure, root_certificates=root_certificates, private_key=private_key, certificate_chain=certificate_chain, server_host_override=server_host_override) +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/status_pb2.py b/gcloud/bigtable/_generated/status_pb2.py new file mode 100644 index 000000000000..2129d74e625f --- /dev/null +++ b/gcloud/bigtable/_generated/status_pb2.py @@ -0,0 +1,91 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/rpc/status.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + +from gcloud.bigtable._generated import any_pb2 as google_dot_protobuf_dot_any__pb2 + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/rpc/status.proto', + package='google.rpc', + syntax='proto3', + serialized_pb=_b('\n\x17google/rpc/status.proto\x12\ngoogle.rpc\x1a\x19google/protobuf/any.proto\"N\n\x06Status\x12\x0c\n\x04\x63ode\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\t\x12%\n\x07\x64\x65tails\x18\x03 \x03(\x0b\x32\x14.google.protobuf.AnyB\x1f\n\x0e\x63om.google.rpcB\x0bStatusProtoP\x01\x62\x06proto3') + , + dependencies=[google_dot_protobuf_dot_any__pb2.DESCRIPTOR,]) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_STATUS = _descriptor.Descriptor( + name='Status', + full_name='google.rpc.Status', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='code', full_name='google.rpc.Status.code', index=0, + number=1, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='message', full_name='google.rpc.Status.message', index=1, + number=2, type=9, cpp_type=9, label=1, + has_default_value=False, default_value=_b("").decode('utf-8'), + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='details', full_name='google.rpc.Status.details', index=2, + number=3, type=11, cpp_type=10, label=3, + has_default_value=False, default_value=[], + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=66, + serialized_end=144, +) + +_STATUS.fields_by_name['details'].message_type = google_dot_protobuf_dot_any__pb2._ANY +DESCRIPTOR.message_types_by_name['Status'] = _STATUS + +Status = _reflection.GeneratedProtocolMessageType('Status', (_message.Message,), dict( + DESCRIPTOR = _STATUS, + __module__ = 'google.rpc.status_pb2' + # @@protoc_insertion_point(class_scope:google.rpc.Status) + )) +_sym_db.RegisterMessage(Status) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\016com.google.rpcB\013StatusProtoP\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/gcloud/bigtable/_generated/timestamp_pb2.py b/gcloud/bigtable/_generated/timestamp_pb2.py new file mode 100644 index 000000000000..6baa9b46bb99 --- /dev/null +++ b/gcloud/bigtable/_generated/timestamp_pb2.py @@ -0,0 +1,81 @@ +# Generated by the protocol buffer compiler. DO NOT EDIT! +# source: google/protobuf/timestamp.proto + +import sys +_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1')) +from google.protobuf import descriptor as _descriptor +from google.protobuf import message as _message +from google.protobuf import reflection as _reflection +from google.protobuf import symbol_database as _symbol_database +from google.protobuf import descriptor_pb2 +# @@protoc_insertion_point(imports) + +_sym_db = _symbol_database.Default() + + + + +DESCRIPTOR = _descriptor.FileDescriptor( + name='google/protobuf/timestamp.proto', + package='google.protobuf', + syntax='proto3', + serialized_pb=_b('\n\x1fgoogle/protobuf/timestamp.proto\x12\x0fgoogle.protobuf\"+\n\tTimestamp\x12\x0f\n\x07seconds\x18\x01 \x01(\x03\x12\r\n\x05nanos\x18\x02 \x01(\x05\x42*\n\x13\x63om.google.protobufB\x0eTimestampProtoP\x01\xa0\x01\x01\x62\x06proto3') +) +_sym_db.RegisterFileDescriptor(DESCRIPTOR) + + + + +_TIMESTAMP = _descriptor.Descriptor( + name='Timestamp', + full_name='google.protobuf.Timestamp', + filename=None, + file=DESCRIPTOR, + containing_type=None, + fields=[ + _descriptor.FieldDescriptor( + name='seconds', full_name='google.protobuf.Timestamp.seconds', index=0, + number=1, type=3, cpp_type=2, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + _descriptor.FieldDescriptor( + name='nanos', full_name='google.protobuf.Timestamp.nanos', index=1, + number=2, type=5, cpp_type=1, label=1, + has_default_value=False, default_value=0, + message_type=None, enum_type=None, containing_type=None, + is_extension=False, extension_scope=None, + options=None), + ], + extensions=[ + ], + nested_types=[], + enum_types=[ + ], + options=None, + is_extendable=False, + syntax='proto3', + extension_ranges=[], + oneofs=[ + ], + serialized_start=52, + serialized_end=95, +) + +DESCRIPTOR.message_types_by_name['Timestamp'] = _TIMESTAMP + +Timestamp = _reflection.GeneratedProtocolMessageType('Timestamp', (_message.Message,), dict( + DESCRIPTOR = _TIMESTAMP, + __module__ = 'google.protobuf.timestamp_pb2' + # @@protoc_insertion_point(class_scope:google.protobuf.Timestamp) + )) +_sym_db.RegisterMessage(Timestamp) + + +DESCRIPTOR.has_options = True +DESCRIPTOR._options = _descriptor._ParseOptions(descriptor_pb2.FileOptions(), _b('\n\023com.google.protobufB\016TimestampProtoP\001\240\001\001')) +import abc +from grpc.early_adopter import implementations +from grpc.framework.alpha import utilities +# @@protoc_insertion_point(module_scope) diff --git a/run_pylint.py b/run_pylint.py index 4c1d1e1df3dc..267fa504e778 100644 --- a/run_pylint.py +++ b/run_pylint.py @@ -29,6 +29,7 @@ IGNORED_DIRECTORIES = [ + 'gcloud/bigtable/_generated', ] IGNORED_FILES = [ 'gcloud/datastore/_datastore_v1_pb2.py', diff --git a/scripts/check_generate.py b/scripts/check_generate.py new file mode 100644 index 000000000000..a126cc659f60 --- /dev/null +++ b/scripts/check_generate.py @@ -0,0 +1,37 @@ +# Copyright 2015 Google Inc. All rights reserved. +# +# 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 +# +# http://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. + +"""Checking that protobuf generated modules import correctly.""" + +from __future__ import print_function + +import glob +import os + + +def main(): + """Import all PB2 files.""" + print('>>> import gcloud.bigtable._generated') + _ = __import__('gcloud.bigtable._generated') + pb2_files = sorted(glob.glob('gcloud/bigtable/_generated/*pb2.py')) + for filename in pb2_files: + basename = os.path.basename(filename) + module_name, _ = os.path.splitext(basename) + + print('>>> from gcloud.bigtable._generated import ' + module_name) + _ = __import__('gcloud.bigtable._generated', fromlist=[module_name]) + + +if __name__ == '__main__': + main() diff --git a/scripts/rewrite_imports.py b/scripts/rewrite_imports.py new file mode 100644 index 000000000000..71f83d8b946a --- /dev/null +++ b/scripts/rewrite_imports.py @@ -0,0 +1,169 @@ +# Copyright 2015 Google Inc. All rights reserved. +# +# 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 +# +# http://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. + +"""Build script for rewriting imports for protobuf generated modules. + +Intended to be used for Google Cloud Bigtable protos (google/bigtable/v1) +and the dependent modules (google/api and google/protobuf). +""" + +import glob + + +IMPORT_TEMPLATE = 'import %s' +IMPORT_FROM_TEMPLATE = 'from %s import ' +PROTOBUF_IMPORT_TEMPLATE = 'from google.protobuf import %s ' +REPLACE_PROTOBUF_IMPORT_TEMPLATE = 'from gcloud.bigtable._generated import %s ' +REPLACEMENTS = { + 'google.api': 'gcloud.bigtable._generated', + 'google.bigtable.admin.cluster.v1': 'gcloud.bigtable._generated', + 'google.bigtable.admin.table.v1': 'gcloud.bigtable._generated', + 'google.bigtable.v1': 'gcloud.bigtable._generated', + 'google.longrunning': 'gcloud.bigtable._generated', + 'google.rpc': 'gcloud.bigtable._generated', +} +GOOGLE_PROTOBUF_CUSTOM = ( + 'any_pb2', + 'duration_pb2', + 'empty_pb2', + 'timestamp_pb2', +) + + +def transform_old_to_new(line, old_module, new_module, + ignore_import_from=False): + """Transforms from an old module to a new one. + + First checks if a line starts with + "from {old_module} import ..." + then checks if the line contains + "import {old_module} ..." + and finally checks if the line starts with (ignoring whitespace) + "{old_module} ..." + + In any of these cases, "{old_module}" is replaced with "{new_module}". + If none match, nothing is returned. + + :type line: str + :param line: The line to be transformed. + + :type old_module: str + :param old_module: The import to be re-written. + + :type new_module: str + :param new_module: The new location of the re-written import. + + :type ignore_import_from: bool + :param ignore_import_from: Flag to determine if the "from * import" + statements should be ignored. + + :rtype: :class:`str` or :data:`NoneType ` + :returns: The transformed line if the old module was found, otherwise + does nothing. + """ + if not ignore_import_from: + import_from_statement = IMPORT_FROM_TEMPLATE % (old_module,) + if line.startswith(import_from_statement): + new_import_from_statement = IMPORT_FROM_TEMPLATE % (new_module,) + # Only replace the first instance of the import statement. + return line.replace(import_from_statement, + new_import_from_statement, 1) + + # If the line doesn't start with a "from * import *" statement, it + # may still contain a "import * ..." statement. + import_statement = IMPORT_TEMPLATE % (old_module,) + if import_statement in line: + new_import_statement = IMPORT_TEMPLATE % (new_module,) + # Only replace the first instance of the import statement. + return line.replace(import_statement, + new_import_statement, 1) + + # Also need to change references to the standalone imports. As a + # stop-gap we fix references to them at the beginning of a line + # (ignoring whitespace). + if line.lstrip().startswith(old_module): + # Only replace the first instance of the old_module. + return line.replace(old_module, new_module, 1) + + +def transform_line(line): + """Transforms an import line in a PB2 module. + + If the line is not an import of one of the packages in + ``REPLACEMENTS`` or ``GOOGLE_PROTOBUF_CUSTOM``, does nothing and returns + the original. Otherwise it replaces the package matched with our local + package or directly rewrites the custom ``google.protobuf`` import + statement. + + :type line: str + :param line: The line to be transformed. + + :rtype: str + :returns: The transformed line. + """ + for old_module, new_module in REPLACEMENTS.iteritems(): + result = transform_old_to_new(line, old_module, new_module) + if result is not None: + return result + + for custom_protobuf_module in GOOGLE_PROTOBUF_CUSTOM: + # We don't use the "from * import" check in transform_old_to_new + # because part of `google.protobuf` comes from the installed + # `protobuf` library. + import_from_statement = PROTOBUF_IMPORT_TEMPLATE % ( + custom_protobuf_module,) + if line.startswith(import_from_statement): + new_import_from_statement = REPLACE_PROTOBUF_IMPORT_TEMPLATE % ( + custom_protobuf_module,) + # Only replace the first instance of the import statement. + return line.replace(import_from_statement, + new_import_from_statement, 1) + + old_module = 'google.protobuf.' + custom_protobuf_module + new_module = 'gcloud.bigtable._generated.' + custom_protobuf_module + result = transform_old_to_new(line, old_module, new_module, + ignore_import_from=True) + if result is not None: + return result + + # If no matches, there is nothing to transform. + return line + + +def rewrite_file(filename): + """Rewrites a given PB2 modules. + + :type filename: str + :param filename: The name of the file to be rewritten. + """ + with open(filename, 'rU') as file_obj: + content_lines = file_obj.read().split('\n') + + new_content = [] + for line in content_lines: + new_content.append(transform_line(line)) + + with open(filename, 'w') as file_obj: + file_obj.write('\n'.join(new_content)) + + +def main(): + """Rewrites all PB2 files.""" + pb2_files = glob.glob('gcloud/bigtable/_generated/*pb2.py') + for filename in pb2_files: + rewrite_file(filename) + + +if __name__ == '__main__': + main() diff --git a/tox.ini b/tox.ini index f8ec8c3434a6..08cd67131bf6 100644 --- a/tox.ini +++ b/tox.ini @@ -55,7 +55,7 @@ deps = {[testenv:docs]deps} passenv = {[testenv:docs]passenv} [pep8] -exclude = gcloud/datastore/_datastore_v1_pb2.py,docs/conf.py +exclude = gcloud/datastore/_datastore_v1_pb2.py,gcloud/bigtable/_generated/*,docs/conf.py verbose = 1 [testenv:lint]