From 1c56be78f1aae8dd5cd93e81188135d72cc80fdc Mon Sep 17 00:00:00 2001 From: Yoshi Automation Bot Date: Fri, 7 Aug 2020 15:16:47 -0700 Subject: [PATCH] fix: update retry config (#47) * chore: update grpc to v1.30.0 PiperOrigin-RevId: 317949519 Source-Author: Google APIs Source-Date: Tue Jun 23 15:22:22 2020 -0700 Source-Repo: googleapis/googleapis Source-Sha: 7157f9552747421572cf1ab3aec1105c05ebd4f9 Source-Link: https://github.com/googleapis/googleapis/commit/7157f9552747421572cf1ab3aec1105c05ebd4f9 * Updates to build Google Ads API build files. PiperOrigin-RevId: 318028816 Source-Author: Google APIs Source-Date: Wed Jun 24 02:32:38 2020 -0700 Source-Repo: googleapis/googleapis Source-Sha: b882b8e6bfcd708042ff00f7adc67ce750817dd0 Source-Link: https://github.com/googleapis/googleapis/commit/b882b8e6bfcd708042ff00f7adc67ce750817dd0 * fix: migrate datacatalog/v1beta1 to grpc_service_config PiperOrigin-RevId: 318311657 Source-Author: Google APIs Source-Date: Thu Jun 25 11:27:42 2020 -0700 Source-Repo: googleapis/googleapis Source-Sha: ed796a1d5787046c24261dd059874721f93c2b7a Source-Link: https://github.com/googleapis/googleapis/commit/ed796a1d5787046c24261dd059874721f93c2b7a * fix: migrate datacatalog/v1 to grpc_service_config PiperOrigin-RevId: 318312024 Source-Author: Google APIs Source-Date: Thu Jun 25 11:29:46 2020 -0700 Source-Repo: googleapis/googleapis Source-Sha: 8f57b478971817195a74d47632dd13a1c409f012 Source-Link: https://github.com/googleapis/googleapis/commit/8f57b478971817195a74d47632dd13a1c409f012 * Update protobuf and gapic-generator-csharp versions. PiperOrigin-RevId: 320411362 Source-Author: Google APIs Source-Date: Thu Jul 9 09:26:49 2020 -0700 Source-Repo: googleapis/googleapis Source-Sha: db69b46790b55a82ab7cfa473d031da787bc7591 Source-Link: https://github.com/googleapis/googleapis/commit/db69b46790b55a82ab7cfa473d031da787bc7591 --- .../gapic/data_catalog_client_config.py | 141 ++- .../datacatalog_v1/proto/common_pb2_grpc.py | 1 + .../proto/datacatalog_pb2_grpc.py | 1061 ++++++++++++++--- .../proto/gcs_fileset_spec_pb2_grpc.py | 1 + .../datacatalog_v1/proto/schema_pb2_grpc.py | 1 + .../datacatalog_v1/proto/search_pb2_grpc.py | 1 + .../proto/table_spec_pb2_grpc.py | 1 + .../datacatalog_v1/proto/tags_pb2_grpc.py | 1 + .../proto/timestamps_pb2_grpc.py | 1 + .../gapic/data_catalog_client.py | 976 +++++++-------- .../gapic/data_catalog_client_config.py | 177 +-- .../gapic/policy_tag_manager_client_config.py | 85 +- ...tag_manager_serialization_client_config.py | 41 +- .../transports/data_catalog_grpc_transport.py | 228 ++-- .../proto/common_pb2_grpc.py | 1 + .../proto/datacatalog_pb2_grpc.py | 1043 +++++++++++++--- .../proto/gcs_fileset_spec_pb2_grpc.py | 1 + .../proto/policytagmanager_pb2_grpc.py | 405 ++++++- .../policytagmanagerserialization_pb2_grpc.py | 90 +- .../proto/schema_pb2_grpc.py | 1 + .../proto/search_pb2_grpc.py | 1 + .../proto/table_spec_pb2_grpc.py | 1 + .../proto/tags_pb2_grpc.py | 1 + .../proto/timestamps_pb2_grpc.py | 1 + synth.metadata | 6 +- .../test_data_catalog_client_v1beta1.py | 412 +++---- 26 files changed, 3332 insertions(+), 1347 deletions(-) diff --git a/google/cloud/datacatalog_v1/gapic/data_catalog_client_config.py b/google/cloud/datacatalog_v1/gapic/data_catalog_client_config.py index 2f91f586..d59dc6a5 100644 --- a/google/cloud/datacatalog_v1/gapic/data_catalog_client_config.py +++ b/google/cloud/datacatalog_v1/gapic/data_catalog_client_config.py @@ -2,155 +2,174 @@ "interfaces": { "google.cloud.datacatalog.v1.DataCatalog": { "retry_codes": { - "idempotent": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], - "non_idempotent": [], + "retry_policy_1_codes": ["UNAVAILABLE"], + "no_retry_codes": [], + "no_retry_1_codes": [], }, "retry_params": { - "default": { + "retry_policy_1_params": { "initial_retry_delay_millis": 100, "retry_delay_multiplier": 1.3, "max_retry_delay_millis": 60000, - "initial_rpc_timeout_millis": 20000, + "initial_rpc_timeout_millis": 60000, "rpc_timeout_multiplier": 1.0, - "max_rpc_timeout_millis": 20000, - "total_timeout_millis": 600000, - } + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 60000, + }, + "no_retry_params": { + "initial_retry_delay_millis": 0, + "retry_delay_multiplier": 0.0, + "max_retry_delay_millis": 0, + "initial_rpc_timeout_millis": 0, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 0, + "total_timeout_millis": 0, + }, + "no_retry_1_params": { + "initial_retry_delay_millis": 0, + "retry_delay_multiplier": 0.0, + "max_retry_delay_millis": 0, + "initial_rpc_timeout_millis": 60000, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 60000, + }, }, "methods": { "SearchCatalog": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "CreateEntryGroup": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "GetEntryGroup": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "UpdateEntryGroup": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "DeleteEntryGroup": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "ListEntryGroups": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "CreateEntry": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "UpdateEntry": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "DeleteEntry": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "GetEntry": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "LookupEntry": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "ListEntries": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "CreateTagTemplate": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "GetTagTemplate": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "UpdateTagTemplate": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "DeleteTagTemplate": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "CreateTagTemplateField": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "UpdateTagTemplateField": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "RenameTagTemplateField": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "DeleteTagTemplateField": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "CreateTag": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "UpdateTag": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "DeleteTag": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "ListTags": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "SetIamPolicy": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "GetIamPolicy": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "TestIamPermissions": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, }, } diff --git a/google/cloud/datacatalog_v1/proto/common_pb2_grpc.py b/google/cloud/datacatalog_v1/proto/common_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1/proto/common_pb2_grpc.py +++ b/google/cloud/datacatalog_v1/proto/common_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1/proto/datacatalog_pb2_grpc.py b/google/cloud/datacatalog_v1/proto/datacatalog_pb2_grpc.py index a3a7f677..8af913ca 100644 --- a/google/cloud/datacatalog_v1/proto/datacatalog_pb2_grpc.py +++ b/google/cloud/datacatalog_v1/proto/datacatalog_pb2_grpc.py @@ -1,4 +1,5 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc from google.cloud.datacatalog_v1.proto import ( @@ -14,15 +15,15 @@ class DataCatalogStub(object): """Data Catalog API service allows clients to discover, understand, and manage - their data. - """ + their data. + """ def __init__(self, channel): """Constructor. - Args: - channel: A grpc.Channel. - """ + Args: + channel: A grpc.Channel. + """ self.SearchCatalog = channel.unary_unary( "/google.cloud.datacatalog.v1.DataCatalog/SearchCatalog", request_serializer=google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.SearchCatalogRequest.SerializeToString, @@ -162,27 +163,27 @@ def __init__(self, channel): class DataCatalogServicer(object): """Data Catalog API service allows clients to discover, understand, and manage - their data. - """ + their data. + """ def SearchCatalog(self, request, context): """Searches Data Catalog for multiple resources like entries, tags that - match a query. + match a query. - This is a custom method - (https://cloud.google.com/apis/design/custom_methods) and does not return - the complete resource, only the resource identifier and high level - fields. Clients can subsequentally call `Get` methods. + This is a custom method + (https://cloud.google.com/apis/design/custom_methods) and does not return + the complete resource, only the resource identifier and high level + fields. Clients can subsequentally call `Get` methods. - Note that Data Catalog search queries do not guarantee full recall. Query - results that match your query may not be returned, even in subsequent - result pages. Also note that results returned (and not returned) can vary - across repeated search queries. + Note that Data Catalog search queries do not guarantee full recall. Query + results that match your query may not be returned, even in subsequent + result pages. Also note that results returned (and not returned) can vary + across repeated search queries. - See [Data Catalog Search - Syntax](https://cloud.google.com/data-catalog/docs/how-to/search-reference) - for more information. - """ + See [Data Catalog Search + Syntax](https://cloud.google.com/data-catalog/docs/how-to/search-reference) + for more information. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") @@ -190,303 +191,303 @@ def SearchCatalog(self, request, context): def CreateEntryGroup(self, request, context): """Creates an EntryGroup. - An entry group contains logically related entries together with Cloud - Identity and Access Management policies that specify the users who can - create, edit, and view entries within the entry group. + An entry group contains logically related entries together with Cloud + Identity and Access Management policies that specify the users who can + create, edit, and view entries within the entry group. - Data Catalog automatically creates an entry group for BigQuery entries - ("@bigquery") and Pub/Sub topics ("@pubsub"). Users create their own entry - group to contain Cloud Storage fileset entries or custom type entries, - and the IAM policies associated with those entries. Entry groups, like - entries, can be searched. + Data Catalog automatically creates an entry group for BigQuery entries + ("@bigquery") and Pub/Sub topics ("@pubsub"). Users create their own entry + group to contain Cloud Storage fileset entries or custom type entries, + and the IAM policies associated with those entries. Entry groups, like + entries, can be searched. - A maximum of 10,000 entry groups may be created per organization across all - locations. + A maximum of 10,000 entry groups may be created per organization across all + locations. - Users should enable the Data Catalog API in the project identified by - the `parent` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + Users should enable the Data Catalog API in the project identified by + the `parent` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetEntryGroup(self, request, context): """Gets an EntryGroup. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateEntryGroup(self, request, context): """Updates an EntryGroup. The user should enable the Data Catalog API in the - project identified by the `entry_group.name` parameter (see [Data Catalog - Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + project identified by the `entry_group.name` parameter (see [Data Catalog + Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteEntryGroup(self, request, context): """Deletes an EntryGroup. Only entry groups that do not contain entries can be - deleted. Users should enable the Data Catalog API in the project - identified by the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + deleted. Users should enable the Data Catalog API in the project + identified by the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def ListEntryGroups(self, request, context): """Lists entry groups. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateEntry(self, request, context): """Creates an entry. Only entries of 'FILESET' type or user-specified type can - be created. + be created. - Users should enable the Data Catalog API in the project identified by - the `parent` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). + Users should enable the Data Catalog API in the project identified by + the `parent` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). - A maximum of 100,000 entries may be created per entry group. - """ + A maximum of 100,000 entries may be created per entry group. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateEntry(self, request, context): """Updates an existing entry. - Users should enable the Data Catalog API in the project identified by - the `entry.name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + Users should enable the Data Catalog API in the project identified by + the `entry.name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteEntry(self, request, context): """Deletes an existing entry. Only entries created through - [CreateEntry][google.cloud.datacatalog.v1.DataCatalog.CreateEntry] - method can be deleted. - Users should enable the Data Catalog API in the project identified by - the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + [CreateEntry][google.cloud.datacatalog.v1.DataCatalog.CreateEntry] + method can be deleted. + Users should enable the Data Catalog API in the project identified by + the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetEntry(self, request, context): """Gets an entry. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def LookupEntry(self, request, context): """Get an entry by target resource name. This method allows clients to use - the resource name from the source Google Cloud Platform service to get the - Data Catalog Entry. - """ + the resource name from the source Google Cloud Platform service to get the + Data Catalog Entry. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def ListEntries(self, request, context): """Lists entries. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateTagTemplate(self, request, context): """Creates a tag template. The user should enable the Data Catalog API in - the project identified by the `parent` parameter (see [Data Catalog - Resource - Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - """ + the project identified by the `parent` parameter (see [Data Catalog + Resource + Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetTagTemplate(self, request, context): """Gets a tag template. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateTagTemplate(self, request, context): """Updates a tag template. This method cannot be used to update the fields of - a template. The tag template fields are represented as separate resources - and should be updated using their own create/update/delete methods. - Users should enable the Data Catalog API in the project identified by - the `tag_template.name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + a template. The tag template fields are represented as separate resources + and should be updated using their own create/update/delete methods. + Users should enable the Data Catalog API in the project identified by + the `tag_template.name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteTagTemplate(self, request, context): """Deletes a tag template and all tags using the template. - Users should enable the Data Catalog API in the project identified by - the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + Users should enable the Data Catalog API in the project identified by + the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateTagTemplateField(self, request, context): """Creates a field in a tag template. The user should enable the Data Catalog - API in the project identified by the `parent` parameter (see - [Data Catalog Resource - Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - """ + API in the project identified by the `parent` parameter (see + [Data Catalog Resource + Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateTagTemplateField(self, request, context): """Updates a field in a tag template. This method cannot be used to update the - field type. Users should enable the Data Catalog API in the project - identified by the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + field type. Users should enable the Data Catalog API in the project + identified by the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def RenameTagTemplateField(self, request, context): """Renames a field in a tag template. The user should enable the Data Catalog - API in the project identified by the `name` parameter (see [Data Catalog - Resource - Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - """ + API in the project identified by the `name` parameter (see [Data Catalog + Resource + Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteTagTemplateField(self, request, context): """Deletes a field in a tag template and all uses of that field. - Users should enable the Data Catalog API in the project identified by - the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + Users should enable the Data Catalog API in the project identified by + the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateTag(self, request, context): """Creates a tag on an [Entry][google.cloud.datacatalog.v1.Entry]. - Note: The project identified by the `parent` parameter for the - [tag](https://cloud.google.com/data-catalog/docs/reference/rest/v1/projects.locations.entryGroups.entries.tags/create#path-parameters) - and the - [tag - template](https://cloud.google.com/data-catalog/docs/reference/rest/v1/projects.locations.tagTemplates/create#path-parameters) - used to create the tag must be from the same organization. - """ + Note: The project identified by the `parent` parameter for the + [tag](https://cloud.google.com/data-catalog/docs/reference/rest/v1/projects.locations.entryGroups.entries.tags/create#path-parameters) + and the + [tag + template](https://cloud.google.com/data-catalog/docs/reference/rest/v1/projects.locations.tagTemplates/create#path-parameters) + used to create the tag must be from the same organization. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateTag(self, request, context): """Updates an existing tag. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteTag(self, request, context): """Deletes a tag. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def ListTags(self, request, context): """Lists the tags on an [Entry][google.cloud.datacatalog.v1.Entry]. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def SetIamPolicy(self, request, context): """Sets the access control policy for a resource. Replaces any existing - policy. - Supported resources are: - - Tag templates. - - Entries. - - Entry groups. - Note, this method cannot be used to manage policies for BigQuery, Pub/Sub - and any external Google Cloud Platform resources synced to Data Catalog. - - Callers must have following Google IAM permission - - `datacatalog.tagTemplates.setIamPolicy` to set policies on tag - templates. - - `datacatalog.entries.setIamPolicy` to set policies on entries. - - `datacatalog.entryGroups.setIamPolicy` to set policies on entry groups. - """ + policy. + Supported resources are: + - Tag templates. + - Entries. + - Entry groups. + Note, this method cannot be used to manage policies for BigQuery, Pub/Sub + and any external Google Cloud Platform resources synced to Data Catalog. + + Callers must have following Google IAM permission + - `datacatalog.tagTemplates.setIamPolicy` to set policies on tag + templates. + - `datacatalog.entries.setIamPolicy` to set policies on entries. + - `datacatalog.entryGroups.setIamPolicy` to set policies on entry groups. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetIamPolicy(self, request, context): """Gets the access control policy for a resource. A `NOT_FOUND` error - is returned if the resource does not exist. An empty policy is returned - if the resource exists but does not have a policy set on it. - - Supported resources are: - - Tag templates. - - Entries. - - Entry groups. - Note, this method cannot be used to manage policies for BigQuery, Pub/Sub - and any external Google Cloud Platform resources synced to Data Catalog. - - Callers must have following Google IAM permission - - `datacatalog.tagTemplates.getIamPolicy` to get policies on tag - templates. - - `datacatalog.entries.getIamPolicy` to get policies on entries. - - `datacatalog.entryGroups.getIamPolicy` to get policies on entry groups. - """ + is returned if the resource does not exist. An empty policy is returned + if the resource exists but does not have a policy set on it. + + Supported resources are: + - Tag templates. + - Entries. + - Entry groups. + Note, this method cannot be used to manage policies for BigQuery, Pub/Sub + and any external Google Cloud Platform resources synced to Data Catalog. + + Callers must have following Google IAM permission + - `datacatalog.tagTemplates.getIamPolicy` to get policies on tag + templates. + - `datacatalog.entries.getIamPolicy` to get policies on entries. + - `datacatalog.entryGroups.getIamPolicy` to get policies on entry groups. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def TestIamPermissions(self, request, context): """Returns the caller's permissions on a resource. - If the resource does not exist, an empty set of permissions is returned - (We don't return a `NOT_FOUND` error). - - Supported resources are: - - Tag templates. - - Entries. - - Entry groups. - Note, this method cannot be used to manage policies for BigQuery, Pub/Sub - and any external Google Cloud Platform resources synced to Data Catalog. - - A caller is not required to have Google IAM permission to make this - request. - """ + If the resource does not exist, an empty set of permissions is returned + (We don't return a `NOT_FOUND` error). + + Supported resources are: + - Tag templates. + - Entries. + - Entry groups. + Note, this method cannot be used to manage policies for BigQuery, Pub/Sub + and any external Google Cloud Platform resources synced to Data Catalog. + + A caller is not required to have Google IAM permission to make this + request. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") @@ -634,3 +635,739 @@ def add_DataCatalogServicer_to_server(servicer, server): "google.cloud.datacatalog.v1.DataCatalog", rpc_method_handlers ) server.add_generic_rpc_handlers((generic_handler,)) + + +# This class is part of an EXPERIMENTAL API. +class DataCatalog(object): + """Data Catalog API service allows clients to discover, understand, and manage + their data. + """ + + @staticmethod + def SearchCatalog( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/SearchCatalog", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.SearchCatalogRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.SearchCatalogResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateEntryGroup( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/CreateEntryGroup", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.CreateEntryGroupRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.EntryGroup.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetEntryGroup( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/GetEntryGroup", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.GetEntryGroupRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.EntryGroup.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateEntryGroup( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/UpdateEntryGroup", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.UpdateEntryGroupRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.EntryGroup.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteEntryGroup( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/DeleteEntryGroup", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.DeleteEntryGroupRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListEntryGroups( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/ListEntryGroups", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.ListEntryGroupsRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.ListEntryGroupsResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/CreateEntry", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.CreateEntryRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.Entry.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/UpdateEntry", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.UpdateEntryRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.Entry.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/DeleteEntry", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.DeleteEntryRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/GetEntry", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.GetEntryRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.Entry.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def LookupEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/LookupEntry", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.LookupEntryRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.Entry.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListEntries( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/ListEntries", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.ListEntriesRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.ListEntriesResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateTagTemplate( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/CreateTagTemplate", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.CreateTagTemplateRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_tags__pb2.TagTemplate.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetTagTemplate( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/GetTagTemplate", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.GetTagTemplateRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_tags__pb2.TagTemplate.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateTagTemplate( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/UpdateTagTemplate", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.UpdateTagTemplateRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_tags__pb2.TagTemplate.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteTagTemplate( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/DeleteTagTemplate", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.DeleteTagTemplateRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateTagTemplateField( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/CreateTagTemplateField", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.CreateTagTemplateFieldRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_tags__pb2.TagTemplateField.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateTagTemplateField( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/UpdateTagTemplateField", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.UpdateTagTemplateFieldRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_tags__pb2.TagTemplateField.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def RenameTagTemplateField( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/RenameTagTemplateField", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.RenameTagTemplateFieldRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_tags__pb2.TagTemplateField.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteTagTemplateField( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/DeleteTagTemplateField", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.DeleteTagTemplateFieldRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/CreateTag", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.CreateTagRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_tags__pb2.Tag.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/UpdateTag", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.UpdateTagRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_tags__pb2.Tag.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/DeleteTag", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.DeleteTagRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListTags( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/ListTags", + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.ListTagsRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1_dot_proto_dot_datacatalog__pb2.ListTagsResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def SetIamPolicy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/SetIamPolicy", + google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.SerializeToString, + google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetIamPolicy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/GetIamPolicy", + google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.SerializeToString, + google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def TestIamPermissions( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1.DataCatalog/TestIamPermissions", + google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.SerializeToString, + google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) diff --git a/google/cloud/datacatalog_v1/proto/gcs_fileset_spec_pb2_grpc.py b/google/cloud/datacatalog_v1/proto/gcs_fileset_spec_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1/proto/gcs_fileset_spec_pb2_grpc.py +++ b/google/cloud/datacatalog_v1/proto/gcs_fileset_spec_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1/proto/schema_pb2_grpc.py b/google/cloud/datacatalog_v1/proto/schema_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1/proto/schema_pb2_grpc.py +++ b/google/cloud/datacatalog_v1/proto/schema_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1/proto/search_pb2_grpc.py b/google/cloud/datacatalog_v1/proto/search_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1/proto/search_pb2_grpc.py +++ b/google/cloud/datacatalog_v1/proto/search_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1/proto/table_spec_pb2_grpc.py b/google/cloud/datacatalog_v1/proto/table_spec_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1/proto/table_spec_pb2_grpc.py +++ b/google/cloud/datacatalog_v1/proto/table_spec_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1/proto/tags_pb2_grpc.py b/google/cloud/datacatalog_v1/proto/tags_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1/proto/tags_pb2_grpc.py +++ b/google/cloud/datacatalog_v1/proto/tags_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1/proto/timestamps_pb2_grpc.py b/google/cloud/datacatalog_v1/proto/timestamps_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1/proto/timestamps_pb2_grpc.py +++ b/google/cloud/datacatalog_v1/proto/timestamps_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1beta1/gapic/data_catalog_client.py b/google/cloud/datacatalog_v1beta1/gapic/data_catalog_client.py index 5f130160..c7bc3d3c 100644 --- a/google/cloud/datacatalog_v1beta1/gapic/data_catalog_client.py +++ b/google/cloud/datacatalog_v1beta1/gapic/data_catalog_client.py @@ -399,153 +399,6 @@ def search_catalog( ) return iterator - def delete_entry_group( - self, - name, - force=None, - retry=google.api_core.gapic_v1.method.DEFAULT, - timeout=google.api_core.gapic_v1.method.DEFAULT, - metadata=None, - ): - """ - Deletes an EntryGroup. Only entry groups that do not contain entries - can be deleted. Users should enable the Data Catalog API in the project - identified by the ``name`` parameter (see [Data Catalog Resource - Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - - Example: - >>> from google.cloud import datacatalog_v1beta1 - >>> - >>> client = datacatalog_v1beta1.DataCatalogClient() - >>> - >>> name = client.entry_group_path('[PROJECT]', '[LOCATION]', '[ENTRY_GROUP]') - >>> - >>> client.delete_entry_group(name) - - Args: - name (str): Required. The name of the entry group. For example, - ``projects/{project_id}/locations/{location}/entryGroups/{entry_group_id}``. - force (bool): Optional. If true, deletes all entries in the entry group. - retry (Optional[google.api_core.retry.Retry]): A retry object used - to retry requests. If ``None`` is specified, requests will - be retried using a default configuration. - timeout (Optional[float]): The amount of time, in seconds, to wait - for the request to complete. Note that if ``retry`` is - specified, the timeout applies to each individual attempt. - metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata - that is provided to the method. - - Raises: - google.api_core.exceptions.GoogleAPICallError: If the request - failed for any reason. - google.api_core.exceptions.RetryError: If the request failed due - to a retryable error and retry attempts failed. - ValueError: If the parameters are invalid. - """ - # Wrap the transport method to add retry and timeout logic. - if "delete_entry_group" not in self._inner_api_calls: - self._inner_api_calls[ - "delete_entry_group" - ] = google.api_core.gapic_v1.method.wrap_method( - self.transport.delete_entry_group, - default_retry=self._method_configs["DeleteEntryGroup"].retry, - default_timeout=self._method_configs["DeleteEntryGroup"].timeout, - client_info=self._client_info, - ) - - request = datacatalog_pb2.DeleteEntryGroupRequest(name=name, force=force) - if metadata is None: - metadata = [] - metadata = list(metadata) - try: - routing_header = [("name", name)] - except AttributeError: - pass - else: - routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( - routing_header - ) - metadata.append(routing_metadata) - - self._inner_api_calls["delete_entry_group"]( - request, retry=retry, timeout=timeout, metadata=metadata - ) - - def delete_entry( - self, - name, - retry=google.api_core.gapic_v1.method.DEFAULT, - timeout=google.api_core.gapic_v1.method.DEFAULT, - metadata=None, - ): - """ - Deletes an existing entry. Only entries created through - ``CreateEntry`` method can be deleted. Users should enable the Data - Catalog API in the project identified by the ``name`` parameter (see - [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - - Example: - >>> from google.cloud import datacatalog_v1beta1 - >>> - >>> client = datacatalog_v1beta1.DataCatalogClient() - >>> - >>> name = client.entry_path('[PROJECT]', '[LOCATION]', '[ENTRY_GROUP]', '[ENTRY]') - >>> - >>> client.delete_entry(name) - - Args: - name (str): Required. The name of the entry. Example: - - - projects/{project_id}/locations/{location}/entryGroups/{entry_group_id}/entries/{entry_id} - retry (Optional[google.api_core.retry.Retry]): A retry object used - to retry requests. If ``None`` is specified, requests will - be retried using a default configuration. - timeout (Optional[float]): The amount of time, in seconds, to wait - for the request to complete. Note that if ``retry`` is - specified, the timeout applies to each individual attempt. - metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata - that is provided to the method. - - Raises: - google.api_core.exceptions.GoogleAPICallError: If the request - failed for any reason. - google.api_core.exceptions.RetryError: If the request failed due - to a retryable error and retry attempts failed. - ValueError: If the parameters are invalid. - """ - # Wrap the transport method to add retry and timeout logic. - if "delete_entry" not in self._inner_api_calls: - self._inner_api_calls[ - "delete_entry" - ] = google.api_core.gapic_v1.method.wrap_method( - self.transport.delete_entry, - default_retry=self._method_configs["DeleteEntry"].retry, - default_timeout=self._method_configs["DeleteEntry"].timeout, - client_info=self._client_info, - ) - - request = datacatalog_pb2.DeleteEntryRequest(name=name) - if metadata is None: - metadata = [] - metadata = list(metadata) - try: - routing_header = [("name", name)] - except AttributeError: - pass - else: - routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( - routing_header - ) - metadata.append(routing_metadata) - - self._inner_api_calls["delete_entry"]( - request, retry=retry, timeout=timeout, metadata=metadata - ) - def get_entry( self, name, @@ -679,349 +532,26 @@ def lookup_entry( ValueError: If the parameters are invalid. """ # Wrap the transport method to add retry and timeout logic. - if "lookup_entry" not in self._inner_api_calls: - self._inner_api_calls[ - "lookup_entry" - ] = google.api_core.gapic_v1.method.wrap_method( - self.transport.lookup_entry, - default_retry=self._method_configs["LookupEntry"].retry, - default_timeout=self._method_configs["LookupEntry"].timeout, - client_info=self._client_info, - ) - - # Sanity check: We have some fields which are mutually exclusive; - # raise ValueError if more than one is sent. - google.api_core.protobuf_helpers.check_oneof( - linked_resource=linked_resource, sql_resource=sql_resource - ) - - request = datacatalog_pb2.LookupEntryRequest( - linked_resource=linked_resource, sql_resource=sql_resource - ) - return self._inner_api_calls["lookup_entry"]( - request, retry=retry, timeout=timeout, metadata=metadata - ) - - def delete_tag_template( - self, - name, - force, - retry=google.api_core.gapic_v1.method.DEFAULT, - timeout=google.api_core.gapic_v1.method.DEFAULT, - metadata=None, - ): - """ - Deletes a tag template and all tags using the template. Users should - enable the Data Catalog API in the project identified by the ``name`` - parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - - Example: - >>> from google.cloud import datacatalog_v1beta1 - >>> - >>> client = datacatalog_v1beta1.DataCatalogClient() - >>> - >>> name = client.tag_template_path('[PROJECT]', '[LOCATION]', '[TAG_TEMPLATE]') - >>> - >>> # TODO: Initialize `force`: - >>> force = False - >>> - >>> client.delete_tag_template(name, force) - - Args: - name (str): Required. The name of the tag template to delete. Example: - - - projects/{project_id}/locations/{location}/tagTemplates/{tag_template_id} - force (bool): Required. Currently, this field must always be set to ``true``. This - confirms the deletion of any possible tags using this template. - ``force = false`` will be supported in the future. - retry (Optional[google.api_core.retry.Retry]): A retry object used - to retry requests. If ``None`` is specified, requests will - be retried using a default configuration. - timeout (Optional[float]): The amount of time, in seconds, to wait - for the request to complete. Note that if ``retry`` is - specified, the timeout applies to each individual attempt. - metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata - that is provided to the method. - - Raises: - google.api_core.exceptions.GoogleAPICallError: If the request - failed for any reason. - google.api_core.exceptions.RetryError: If the request failed due - to a retryable error and retry attempts failed. - ValueError: If the parameters are invalid. - """ - # Wrap the transport method to add retry and timeout logic. - if "delete_tag_template" not in self._inner_api_calls: - self._inner_api_calls[ - "delete_tag_template" - ] = google.api_core.gapic_v1.method.wrap_method( - self.transport.delete_tag_template, - default_retry=self._method_configs["DeleteTagTemplate"].retry, - default_timeout=self._method_configs["DeleteTagTemplate"].timeout, - client_info=self._client_info, - ) - - request = datacatalog_pb2.DeleteTagTemplateRequest(name=name, force=force) - if metadata is None: - metadata = [] - metadata = list(metadata) - try: - routing_header = [("name", name)] - except AttributeError: - pass - else: - routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( - routing_header - ) - metadata.append(routing_metadata) - - self._inner_api_calls["delete_tag_template"]( - request, retry=retry, timeout=timeout, metadata=metadata - ) - - def delete_tag_template_field( - self, - name, - force, - retry=google.api_core.gapic_v1.method.DEFAULT, - timeout=google.api_core.gapic_v1.method.DEFAULT, - metadata=None, - ): - """ - Deletes a field in a tag template and all uses of that field. Users - should enable the Data Catalog API in the project identified by the - ``name`` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - - Example: - >>> from google.cloud import datacatalog_v1beta1 - >>> - >>> client = datacatalog_v1beta1.DataCatalogClient() - >>> - >>> name = client.tag_template_field_path('[PROJECT]', '[LOCATION]', '[TAG_TEMPLATE]', '[FIELD]') - >>> - >>> # TODO: Initialize `force`: - >>> force = False - >>> - >>> client.delete_tag_template_field(name, force) - - Args: - name (str): Required. The name of the tag template field to delete. Example: - - - projects/{project_id}/locations/{location}/tagTemplates/{tag_template_id}/fields/{tag_template_field_id} - force (bool): Required. Currently, this field must always be set to ``true``. This - confirms the deletion of this field from any tags using this field. - ``force = false`` will be supported in the future. - retry (Optional[google.api_core.retry.Retry]): A retry object used - to retry requests. If ``None`` is specified, requests will - be retried using a default configuration. - timeout (Optional[float]): The amount of time, in seconds, to wait - for the request to complete. Note that if ``retry`` is - specified, the timeout applies to each individual attempt. - metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata - that is provided to the method. - - Raises: - google.api_core.exceptions.GoogleAPICallError: If the request - failed for any reason. - google.api_core.exceptions.RetryError: If the request failed due - to a retryable error and retry attempts failed. - ValueError: If the parameters are invalid. - """ - # Wrap the transport method to add retry and timeout logic. - if "delete_tag_template_field" not in self._inner_api_calls: - self._inner_api_calls[ - "delete_tag_template_field" - ] = google.api_core.gapic_v1.method.wrap_method( - self.transport.delete_tag_template_field, - default_retry=self._method_configs["DeleteTagTemplateField"].retry, - default_timeout=self._method_configs["DeleteTagTemplateField"].timeout, - client_info=self._client_info, - ) - - request = datacatalog_pb2.DeleteTagTemplateFieldRequest(name=name, force=force) - if metadata is None: - metadata = [] - metadata = list(metadata) - try: - routing_header = [("name", name)] - except AttributeError: - pass - else: - routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( - routing_header - ) - metadata.append(routing_metadata) - - self._inner_api_calls["delete_tag_template_field"]( - request, retry=retry, timeout=timeout, metadata=metadata - ) - - def delete_tag( - self, - name, - retry=google.api_core.gapic_v1.method.DEFAULT, - timeout=google.api_core.gapic_v1.method.DEFAULT, - metadata=None, - ): - """ - Deletes a tag. - - Example: - >>> from google.cloud import datacatalog_v1beta1 - >>> - >>> client = datacatalog_v1beta1.DataCatalogClient() - >>> - >>> name = client.entry_path('[PROJECT]', '[LOCATION]', '[ENTRY_GROUP]', '[ENTRY]') - >>> - >>> client.delete_tag(name) - - Args: - name (str): Required. The name of the tag to delete. Example: - - - projects/{project_id}/locations/{location}/entryGroups/{entry_group_id}/entries/{entry_id}/tags/{tag_id} - retry (Optional[google.api_core.retry.Retry]): A retry object used - to retry requests. If ``None`` is specified, requests will - be retried using a default configuration. - timeout (Optional[float]): The amount of time, in seconds, to wait - for the request to complete. Note that if ``retry`` is - specified, the timeout applies to each individual attempt. - metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata - that is provided to the method. - - Raises: - google.api_core.exceptions.GoogleAPICallError: If the request - failed for any reason. - google.api_core.exceptions.RetryError: If the request failed due - to a retryable error and retry attempts failed. - ValueError: If the parameters are invalid. - """ - # Wrap the transport method to add retry and timeout logic. - if "delete_tag" not in self._inner_api_calls: - self._inner_api_calls[ - "delete_tag" - ] = google.api_core.gapic_v1.method.wrap_method( - self.transport.delete_tag, - default_retry=self._method_configs["DeleteTag"].retry, - default_timeout=self._method_configs["DeleteTag"].timeout, - client_info=self._client_info, - ) - - request = datacatalog_pb2.DeleteTagRequest(name=name) - if metadata is None: - metadata = [] - metadata = list(metadata) - try: - routing_header = [("name", name)] - except AttributeError: - pass - else: - routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( - routing_header - ) - metadata.append(routing_metadata) - - self._inner_api_calls["delete_tag"]( - request, retry=retry, timeout=timeout, metadata=metadata - ) - - def get_iam_policy( - self, - resource, - options_=None, - retry=google.api_core.gapic_v1.method.DEFAULT, - timeout=google.api_core.gapic_v1.method.DEFAULT, - metadata=None, - ): - """ - Gets the access control policy for a resource. A ``NOT_FOUND`` error - is returned if the resource does not exist. An empty policy is returned - if the resource exists but does not have a policy set on it. - - Supported resources are: - - - Tag templates. - - Entries. - - Entry groups. Note, this method cannot be used to manage policies for - BigQuery, Pub/Sub and any external Google Cloud Platform resources - synced to Data Catalog. - - Callers must have following Google IAM permission - - - ``datacatalog.tagTemplates.getIamPolicy`` to get policies on tag - templates. - - ``datacatalog.entries.getIamPolicy`` to get policies on entries. - - ``datacatalog.entryGroups.getIamPolicy`` to get policies on entry - groups. - - Example: - >>> from google.cloud import datacatalog_v1beta1 - >>> - >>> client = datacatalog_v1beta1.DataCatalogClient() - >>> - >>> # TODO: Initialize `resource`: - >>> resource = '' - >>> - >>> response = client.get_iam_policy(resource) - - Args: - resource (str): REQUIRED: The resource for which the policy is being requested. - See the operation documentation for the appropriate value for this field. - options_ (Union[dict, ~google.cloud.datacatalog_v1beta1.types.GetPolicyOptions]): OPTIONAL: A ``GetPolicyOptions`` object for specifying options to - ``GetIamPolicy``. This field is only used by Cloud IAM. - - If a dict is provided, it must be of the same form as the protobuf - message :class:`~google.cloud.datacatalog_v1beta1.types.GetPolicyOptions` - retry (Optional[google.api_core.retry.Retry]): A retry object used - to retry requests. If ``None`` is specified, requests will - be retried using a default configuration. - timeout (Optional[float]): The amount of time, in seconds, to wait - for the request to complete. Note that if ``retry`` is - specified, the timeout applies to each individual attempt. - metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata - that is provided to the method. - - Returns: - A :class:`~google.cloud.datacatalog_v1beta1.types.Policy` instance. - - Raises: - google.api_core.exceptions.GoogleAPICallError: If the request - failed for any reason. - google.api_core.exceptions.RetryError: If the request failed due - to a retryable error and retry attempts failed. - ValueError: If the parameters are invalid. - """ - # Wrap the transport method to add retry and timeout logic. - if "get_iam_policy" not in self._inner_api_calls: + if "lookup_entry" not in self._inner_api_calls: self._inner_api_calls[ - "get_iam_policy" + "lookup_entry" ] = google.api_core.gapic_v1.method.wrap_method( - self.transport.get_iam_policy, - default_retry=self._method_configs["GetIamPolicy"].retry, - default_timeout=self._method_configs["GetIamPolicy"].timeout, + self.transport.lookup_entry, + default_retry=self._method_configs["LookupEntry"].retry, + default_timeout=self._method_configs["LookupEntry"].timeout, client_info=self._client_info, ) - request = iam_policy_pb2.GetIamPolicyRequest( - resource=resource, options=options_ + # Sanity check: We have some fields which are mutually exclusive; + # raise ValueError if more than one is sent. + google.api_core.protobuf_helpers.check_oneof( + linked_resource=linked_resource, sql_resource=sql_resource ) - if metadata is None: - metadata = [] - metadata = list(metadata) - try: - routing_header = [("resource", resource)] - except AttributeError: - pass - else: - routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( - routing_header - ) - metadata.append(routing_metadata) - return self._inner_api_calls["get_iam_policy"]( + request = datacatalog_pb2.LookupEntryRequest( + linked_resource=linked_resource, sql_resource=sql_resource + ) + return self._inner_api_calls["lookup_entry"]( request, retry=retry, timeout=timeout, metadata=metadata ) @@ -1279,6 +809,80 @@ def get_entry_group( request, retry=retry, timeout=timeout, metadata=metadata ) + def delete_entry_group( + self, + name, + force=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Deletes an EntryGroup. Only entry groups that do not contain entries + can be deleted. Users should enable the Data Catalog API in the project + identified by the ``name`` parameter (see [Data Catalog Resource + Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + + Example: + >>> from google.cloud import datacatalog_v1beta1 + >>> + >>> client = datacatalog_v1beta1.DataCatalogClient() + >>> + >>> name = client.entry_group_path('[PROJECT]', '[LOCATION]', '[ENTRY_GROUP]') + >>> + >>> client.delete_entry_group(name) + + Args: + name (str): Required. The name of the entry group. For example, + ``projects/{project_id}/locations/{location}/entryGroups/{entry_group_id}``. + force (bool): Optional. If true, deletes all entries in the entry group. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "delete_entry_group" not in self._inner_api_calls: + self._inner_api_calls[ + "delete_entry_group" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.delete_entry_group, + default_retry=self._method_configs["DeleteEntryGroup"].retry, + default_timeout=self._method_configs["DeleteEntryGroup"].timeout, + client_info=self._client_info, + ) + + request = datacatalog_pb2.DeleteEntryGroupRequest(name=name, force=force) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + self._inner_api_calls["delete_entry_group"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + def list_entry_groups( self, parent, @@ -1591,6 +1195,79 @@ def update_entry( request, retry=retry, timeout=timeout, metadata=metadata ) + def delete_entry( + self, + name, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Deletes an existing entry. Only entries created through + ``CreateEntry`` method can be deleted. Users should enable the Data + Catalog API in the project identified by the ``name`` parameter (see + [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + + Example: + >>> from google.cloud import datacatalog_v1beta1 + >>> + >>> client = datacatalog_v1beta1.DataCatalogClient() + >>> + >>> name = client.entry_path('[PROJECT]', '[LOCATION]', '[ENTRY_GROUP]', '[ENTRY]') + >>> + >>> client.delete_entry(name) + + Args: + name (str): Required. The name of the entry. Example: + + - projects/{project_id}/locations/{location}/entryGroups/{entry_group_id}/entries/{entry_id} + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "delete_entry" not in self._inner_api_calls: + self._inner_api_calls[ + "delete_entry" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.delete_entry, + default_retry=self._method_configs["DeleteEntry"].retry, + default_timeout=self._method_configs["DeleteEntry"].timeout, + client_info=self._client_info, + ) + + request = datacatalog_pb2.DeleteEntryRequest(name=name) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + self._inner_api_calls["delete_entry"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + def list_entries( self, parent, @@ -1942,14 +1619,93 @@ def update_tag_template( client_info=self._client_info, ) - request = datacatalog_pb2.UpdateTagTemplateRequest( - tag_template=tag_template, update_mask=update_mask - ) + request = datacatalog_pb2.UpdateTagTemplateRequest( + tag_template=tag_template, update_mask=update_mask + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("tag_template.name", tag_template.name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["update_tag_template"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + + def delete_tag_template( + self, + name, + force, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Deletes a tag template and all tags using the template. Users should + enable the Data Catalog API in the project identified by the ``name`` + parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + + Example: + >>> from google.cloud import datacatalog_v1beta1 + >>> + >>> client = datacatalog_v1beta1.DataCatalogClient() + >>> + >>> name = client.tag_template_path('[PROJECT]', '[LOCATION]', '[TAG_TEMPLATE]') + >>> + >>> # TODO: Initialize `force`: + >>> force = False + >>> + >>> client.delete_tag_template(name, force) + + Args: + name (str): Required. The name of the tag template to delete. Example: + + - projects/{project_id}/locations/{location}/tagTemplates/{tag_template_id} + force (bool): Required. Currently, this field must always be set to ``true``. This + confirms the deletion of any possible tags using this template. + ``force = false`` will be supported in the future. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "delete_tag_template" not in self._inner_api_calls: + self._inner_api_calls[ + "delete_tag_template" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.delete_tag_template, + default_retry=self._method_configs["DeleteTagTemplate"].retry, + default_timeout=self._method_configs["DeleteTagTemplate"].timeout, + client_info=self._client_info, + ) + + request = datacatalog_pb2.DeleteTagTemplateRequest(name=name, force=force) if metadata is None: metadata = [] metadata = list(metadata) try: - routing_header = [("tag_template.name", tag_template.name)] + routing_header = [("name", name)] except AttributeError: pass else: @@ -1958,7 +1714,7 @@ def update_tag_template( ) metadata.append(routing_metadata) - return self._inner_api_calls["update_tag_template"]( + self._inner_api_calls["delete_tag_template"]( request, retry=retry, timeout=timeout, metadata=metadata ) @@ -2248,6 +2004,85 @@ def rename_tag_template_field( request, retry=retry, timeout=timeout, metadata=metadata ) + def delete_tag_template_field( + self, + name, + force, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Deletes a field in a tag template and all uses of that field. Users + should enable the Data Catalog API in the project identified by the + ``name`` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + + Example: + >>> from google.cloud import datacatalog_v1beta1 + >>> + >>> client = datacatalog_v1beta1.DataCatalogClient() + >>> + >>> name = client.tag_template_field_path('[PROJECT]', '[LOCATION]', '[TAG_TEMPLATE]', '[FIELD]') + >>> + >>> # TODO: Initialize `force`: + >>> force = False + >>> + >>> client.delete_tag_template_field(name, force) + + Args: + name (str): Required. The name of the tag template field to delete. Example: + + - projects/{project_id}/locations/{location}/tagTemplates/{tag_template_id}/fields/{tag_template_field_id} + force (bool): Required. Currently, this field must always be set to ``true``. This + confirms the deletion of this field from any tags using this field. + ``force = false`` will be supported in the future. + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "delete_tag_template_field" not in self._inner_api_calls: + self._inner_api_calls[ + "delete_tag_template_field" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.delete_tag_template_field, + default_retry=self._method_configs["DeleteTagTemplateField"].retry, + default_timeout=self._method_configs["DeleteTagTemplateField"].timeout, + client_info=self._client_info, + ) + + request = datacatalog_pb2.DeleteTagTemplateFieldRequest(name=name, force=force) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + self._inner_api_calls["delete_tag_template_field"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + def create_tag( self, parent, @@ -2416,6 +2251,74 @@ def update_tag( request, retry=retry, timeout=timeout, metadata=metadata ) + def delete_tag( + self, + name, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Deletes a tag. + + Example: + >>> from google.cloud import datacatalog_v1beta1 + >>> + >>> client = datacatalog_v1beta1.DataCatalogClient() + >>> + >>> name = client.entry_path('[PROJECT]', '[LOCATION]', '[ENTRY_GROUP]', '[ENTRY]') + >>> + >>> client.delete_tag(name) + + Args: + name (str): Required. The name of the tag to delete. Example: + + - projects/{project_id}/locations/{location}/entryGroups/{entry_group_id}/entries/{entry_id}/tags/{tag_id} + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "delete_tag" not in self._inner_api_calls: + self._inner_api_calls[ + "delete_tag" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.delete_tag, + default_retry=self._method_configs["DeleteTag"].retry, + default_timeout=self._method_configs["DeleteTag"].timeout, + client_info=self._client_info, + ) + + request = datacatalog_pb2.DeleteTagRequest(name=name) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("name", name)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + self._inner_api_calls["delete_tag"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + def list_tags( self, parent, @@ -2620,6 +2523,103 @@ def set_iam_policy( request, retry=retry, timeout=timeout, metadata=metadata ) + def get_iam_policy( + self, + resource, + options_=None, + retry=google.api_core.gapic_v1.method.DEFAULT, + timeout=google.api_core.gapic_v1.method.DEFAULT, + metadata=None, + ): + """ + Gets the access control policy for a resource. A ``NOT_FOUND`` error + is returned if the resource does not exist. An empty policy is returned + if the resource exists but does not have a policy set on it. + + Supported resources are: + + - Tag templates. + - Entries. + - Entry groups. Note, this method cannot be used to manage policies for + BigQuery, Pub/Sub and any external Google Cloud Platform resources + synced to Data Catalog. + + Callers must have following Google IAM permission + + - ``datacatalog.tagTemplates.getIamPolicy`` to get policies on tag + templates. + - ``datacatalog.entries.getIamPolicy`` to get policies on entries. + - ``datacatalog.entryGroups.getIamPolicy`` to get policies on entry + groups. + + Example: + >>> from google.cloud import datacatalog_v1beta1 + >>> + >>> client = datacatalog_v1beta1.DataCatalogClient() + >>> + >>> # TODO: Initialize `resource`: + >>> resource = '' + >>> + >>> response = client.get_iam_policy(resource) + + Args: + resource (str): REQUIRED: The resource for which the policy is being requested. + See the operation documentation for the appropriate value for this field. + options_ (Union[dict, ~google.cloud.datacatalog_v1beta1.types.GetPolicyOptions]): OPTIONAL: A ``GetPolicyOptions`` object for specifying options to + ``GetIamPolicy``. This field is only used by Cloud IAM. + + If a dict is provided, it must be of the same form as the protobuf + message :class:`~google.cloud.datacatalog_v1beta1.types.GetPolicyOptions` + retry (Optional[google.api_core.retry.Retry]): A retry object used + to retry requests. If ``None`` is specified, requests will + be retried using a default configuration. + timeout (Optional[float]): The amount of time, in seconds, to wait + for the request to complete. Note that if ``retry`` is + specified, the timeout applies to each individual attempt. + metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata + that is provided to the method. + + Returns: + A :class:`~google.cloud.datacatalog_v1beta1.types.Policy` instance. + + Raises: + google.api_core.exceptions.GoogleAPICallError: If the request + failed for any reason. + google.api_core.exceptions.RetryError: If the request failed due + to a retryable error and retry attempts failed. + ValueError: If the parameters are invalid. + """ + # Wrap the transport method to add retry and timeout logic. + if "get_iam_policy" not in self._inner_api_calls: + self._inner_api_calls[ + "get_iam_policy" + ] = google.api_core.gapic_v1.method.wrap_method( + self.transport.get_iam_policy, + default_retry=self._method_configs["GetIamPolicy"].retry, + default_timeout=self._method_configs["GetIamPolicy"].timeout, + client_info=self._client_info, + ) + + request = iam_policy_pb2.GetIamPolicyRequest( + resource=resource, options=options_ + ) + if metadata is None: + metadata = [] + metadata = list(metadata) + try: + routing_header = [("resource", resource)] + except AttributeError: + pass + else: + routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata( + routing_header + ) + metadata.append(routing_metadata) + + return self._inner_api_calls["get_iam_policy"]( + request, retry=retry, timeout=timeout, metadata=metadata + ) + def test_iam_permissions( self, resource, diff --git a/google/cloud/datacatalog_v1beta1/gapic/data_catalog_client_config.py b/google/cloud/datacatalog_v1beta1/gapic/data_catalog_client_config.py index ec31f73a..e4c261e3 100644 --- a/google/cloud/datacatalog_v1beta1/gapic/data_catalog_client_config.py +++ b/google/cloud/datacatalog_v1beta1/gapic/data_catalog_client_config.py @@ -2,155 +2,174 @@ "interfaces": { "google.cloud.datacatalog.v1beta1.DataCatalog": { "retry_codes": { - "idempotent": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], - "non_idempotent": [], + "retry_policy_1_codes": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], + "no_retry_codes": [], + "no_retry_1_codes": [], }, "retry_params": { - "default": { + "retry_policy_1_params": { "initial_retry_delay_millis": 100, "retry_delay_multiplier": 1.3, "max_retry_delay_millis": 60000, - "initial_rpc_timeout_millis": 20000, + "initial_rpc_timeout_millis": 60000, "rpc_timeout_multiplier": 1.0, - "max_rpc_timeout_millis": 20000, - "total_timeout_millis": 600000, - } + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 60000, + }, + "no_retry_params": { + "initial_retry_delay_millis": 0, + "retry_delay_multiplier": 0.0, + "max_retry_delay_millis": 0, + "initial_rpc_timeout_millis": 0, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 0, + "total_timeout_millis": 0, + }, + "no_retry_1_params": { + "initial_retry_delay_millis": 0, + "retry_delay_multiplier": 0.0, + "max_retry_delay_millis": 0, + "initial_rpc_timeout_millis": 60000, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 60000, + }, }, "methods": { "SearchCatalog": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", - }, - "DeleteEntryGroup": { - "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", - }, - "DeleteEntry": { - "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "GetEntry": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "LookupEntry": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", - }, - "DeleteTagTemplate": { - "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", - }, - "DeleteTagTemplateField": { - "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", - }, - "DeleteTag": { - "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", - }, - "GetIamPolicy": { - "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "CreateEntryGroup": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "UpdateEntryGroup": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "GetEntryGroup": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", + }, + "DeleteEntryGroup": { + "timeout_millis": 60000, + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "ListEntryGroups": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "CreateEntry": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "UpdateEntry": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", + }, + "DeleteEntry": { + "timeout_millis": 60000, + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "ListEntries": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "CreateTagTemplate": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "GetTagTemplate": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "UpdateTagTemplate": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", + }, + "DeleteTagTemplate": { + "timeout_millis": 60000, + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "CreateTagTemplateField": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "UpdateTagTemplateField": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "RenameTagTemplateField": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", + }, + "DeleteTagTemplateField": { + "timeout_millis": 60000, + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "CreateTag": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "UpdateTag": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", + }, + "DeleteTag": { + "timeout_millis": 60000, + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "ListTags": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "retry_policy_1_codes", + "retry_params_name": "retry_policy_1_params", }, "SetIamPolicy": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", + }, + "GetIamPolicy": { + "timeout_millis": 60000, + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, "TestIamPermissions": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_1_params", }, }, } diff --git a/google/cloud/datacatalog_v1beta1/gapic/policy_tag_manager_client_config.py b/google/cloud/datacatalog_v1beta1/gapic/policy_tag_manager_client_config.py index 56875058..57019019 100644 --- a/google/cloud/datacatalog_v1beta1/gapic/policy_tag_manager_client_config.py +++ b/google/cloud/datacatalog_v1beta1/gapic/policy_tag_manager_client_config.py @@ -2,85 +2,104 @@ "interfaces": { "google.cloud.datacatalog.v1beta1.PolicyTagManager": { "retry_codes": { - "idempotent": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], - "non_idempotent": [], + "retry_policy_1_codes": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], + "no_retry_codes": [], + "no_retry_1_codes": [], }, "retry_params": { - "default": { + "retry_policy_1_params": { "initial_retry_delay_millis": 100, "retry_delay_multiplier": 1.3, "max_retry_delay_millis": 60000, - "initial_rpc_timeout_millis": 20000, + "initial_rpc_timeout_millis": 60000, "rpc_timeout_multiplier": 1.0, - "max_rpc_timeout_millis": 20000, - "total_timeout_millis": 600000, - } + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 60000, + }, + "no_retry_params": { + "initial_retry_delay_millis": 0, + "retry_delay_multiplier": 0.0, + "max_retry_delay_millis": 0, + "initial_rpc_timeout_millis": 0, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 0, + "total_timeout_millis": 0, + }, + "no_retry_1_params": { + "initial_retry_delay_millis": 0, + "retry_delay_multiplier": 0.0, + "max_retry_delay_millis": 0, + "initial_rpc_timeout_millis": 60000, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 60000, + }, }, "methods": { "CreateTaxonomy": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "DeleteTaxonomy": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "UpdateTaxonomy": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "ListTaxonomies": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "GetTaxonomy": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "CreatePolicyTag": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "DeletePolicyTag": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "UpdatePolicyTag": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "ListPolicyTags": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "GetPolicyTag": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "GetIamPolicy": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_params", }, "SetIamPolicy": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_params", }, "TestIamPermissions": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_1_codes", + "retry_params_name": "no_retry_params", }, }, } diff --git a/google/cloud/datacatalog_v1beta1/gapic/policy_tag_manager_serialization_client_config.py b/google/cloud/datacatalog_v1beta1/gapic/policy_tag_manager_serialization_client_config.py index 98ba9b0b..ec539229 100644 --- a/google/cloud/datacatalog_v1beta1/gapic/policy_tag_manager_serialization_client_config.py +++ b/google/cloud/datacatalog_v1beta1/gapic/policy_tag_manager_serialization_client_config.py @@ -2,30 +2,49 @@ "interfaces": { "google.cloud.datacatalog.v1beta1.PolicyTagManagerSerialization": { "retry_codes": { - "idempotent": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], - "non_idempotent": [], + "retry_policy_1_codes": ["DEADLINE_EXCEEDED", "UNAVAILABLE"], + "no_retry_codes": [], + "no_retry_1_codes": [], }, "retry_params": { - "default": { + "retry_policy_1_params": { "initial_retry_delay_millis": 100, "retry_delay_multiplier": 1.3, "max_retry_delay_millis": 60000, - "initial_rpc_timeout_millis": 20000, + "initial_rpc_timeout_millis": 60000, "rpc_timeout_multiplier": 1.0, - "max_rpc_timeout_millis": 20000, - "total_timeout_millis": 600000, - } + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 60000, + }, + "no_retry_params": { + "initial_retry_delay_millis": 0, + "retry_delay_multiplier": 0.0, + "max_retry_delay_millis": 0, + "initial_rpc_timeout_millis": 0, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 0, + "total_timeout_millis": 0, + }, + "no_retry_1_params": { + "initial_retry_delay_millis": 0, + "retry_delay_multiplier": 0.0, + "max_retry_delay_millis": 0, + "initial_rpc_timeout_millis": 60000, + "rpc_timeout_multiplier": 1.0, + "max_rpc_timeout_millis": 60000, + "total_timeout_millis": 60000, + }, }, "methods": { "ImportTaxonomies": { "timeout_millis": 60000, - "retry_codes_name": "non_idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, "ExportTaxonomies": { "timeout_millis": 60000, - "retry_codes_name": "idempotent", - "retry_params_name": "default", + "retry_codes_name": "no_retry_codes", + "retry_params_name": "no_retry_params", }, }, } diff --git a/google/cloud/datacatalog_v1beta1/gapic/transports/data_catalog_grpc_transport.py b/google/cloud/datacatalog_v1beta1/gapic/transports/data_catalog_grpc_transport.py index 4761aaa1..2b4a79e5 100644 --- a/google/cloud/datacatalog_v1beta1/gapic/transports/data_catalog_grpc_transport.py +++ b/google/cloud/datacatalog_v1beta1/gapic/transports/data_catalog_grpc_transport.py @@ -135,42 +135,6 @@ def search_catalog(self): """ return self._stubs["data_catalog_stub"].SearchCatalog - @property - def delete_entry_group(self): - """Return the gRPC stub for :meth:`DataCatalogClient.delete_entry_group`. - - Deletes an EntryGroup. Only entry groups that do not contain entries - can be deleted. Users should enable the Data Catalog API in the project - identified by the ``name`` parameter (see [Data Catalog Resource - Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - - Returns: - Callable: A callable which accepts the appropriate - deserialized request object and returns a - deserialized response object. - """ - return self._stubs["data_catalog_stub"].DeleteEntryGroup - - @property - def delete_entry(self): - """Return the gRPC stub for :meth:`DataCatalogClient.delete_entry`. - - Deletes an existing entry. Only entries created through - ``CreateEntry`` method can be deleted. Users should enable the Data - Catalog API in the project identified by the ``name`` parameter (see - [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - - Returns: - Callable: A callable which accepts the appropriate - deserialized request object and returns a - deserialized response object. - """ - return self._stubs["data_catalog_stub"].DeleteEntry - @property def get_entry(self): """Return the gRPC stub for :meth:`DataCatalogClient.get_entry`. @@ -199,84 +163,6 @@ def lookup_entry(self): """ return self._stubs["data_catalog_stub"].LookupEntry - @property - def delete_tag_template(self): - """Return the gRPC stub for :meth:`DataCatalogClient.delete_tag_template`. - - Deletes a tag template and all tags using the template. Users should - enable the Data Catalog API in the project identified by the ``name`` - parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - - Returns: - Callable: A callable which accepts the appropriate - deserialized request object and returns a - deserialized response object. - """ - return self._stubs["data_catalog_stub"].DeleteTagTemplate - - @property - def delete_tag_template_field(self): - """Return the gRPC stub for :meth:`DataCatalogClient.delete_tag_template_field`. - - Deletes a field in a tag template and all uses of that field. Users - should enable the Data Catalog API in the project identified by the - ``name`` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - - Returns: - Callable: A callable which accepts the appropriate - deserialized request object and returns a - deserialized response object. - """ - return self._stubs["data_catalog_stub"].DeleteTagTemplateField - - @property - def delete_tag(self): - """Return the gRPC stub for :meth:`DataCatalogClient.delete_tag`. - - Deletes a tag. - - Returns: - Callable: A callable which accepts the appropriate - deserialized request object and returns a - deserialized response object. - """ - return self._stubs["data_catalog_stub"].DeleteTag - - @property - def get_iam_policy(self): - """Return the gRPC stub for :meth:`DataCatalogClient.get_iam_policy`. - - Gets the access control policy for a resource. A ``NOT_FOUND`` error - is returned if the resource does not exist. An empty policy is returned - if the resource exists but does not have a policy set on it. - - Supported resources are: - - - Tag templates. - - Entries. - - Entry groups. Note, this method cannot be used to manage policies for - BigQuery, Pub/Sub and any external Google Cloud Platform resources - synced to Data Catalog. - - Callers must have following Google IAM permission - - - ``datacatalog.tagTemplates.getIamPolicy`` to get policies on tag - templates. - - ``datacatalog.entries.getIamPolicy`` to get policies on entries. - - ``datacatalog.entryGroups.getIamPolicy`` to get policies on entry - groups. - - Returns: - Callable: A callable which accepts the appropriate - deserialized request object and returns a - deserialized response object. - """ - return self._stubs["data_catalog_stub"].GetIamPolicy - @property def create_entry_group(self): """Return the gRPC stub for :meth:`DataCatalogClient.create_entry_group`. @@ -326,6 +212,24 @@ def get_entry_group(self): """ return self._stubs["data_catalog_stub"].GetEntryGroup + @property + def delete_entry_group(self): + """Return the gRPC stub for :meth:`DataCatalogClient.delete_entry_group`. + + Deletes an EntryGroup. Only entry groups that do not contain entries + can be deleted. Users should enable the Data Catalog API in the project + identified by the ``name`` parameter (see [Data Catalog Resource + Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["data_catalog_stub"].DeleteEntryGroup + @property def list_entry_groups(self): """Return the gRPC stub for :meth:`DataCatalogClient.list_entry_groups`. @@ -377,6 +281,24 @@ def update_entry(self): """ return self._stubs["data_catalog_stub"].UpdateEntry + @property + def delete_entry(self): + """Return the gRPC stub for :meth:`DataCatalogClient.delete_entry`. + + Deletes an existing entry. Only entries created through + ``CreateEntry`` method can be deleted. Users should enable the Data + Catalog API in the project identified by the ``name`` parameter (see + [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["data_catalog_stub"].DeleteEntry + @property def list_entries(self): """Return the gRPC stub for :meth:`DataCatalogClient.list_entries`. @@ -440,6 +362,23 @@ def update_tag_template(self): """ return self._stubs["data_catalog_stub"].UpdateTagTemplate + @property + def delete_tag_template(self): + """Return the gRPC stub for :meth:`DataCatalogClient.delete_tag_template`. + + Deletes a tag template and all tags using the template. Users should + enable the Data Catalog API in the project identified by the ``name`` + parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["data_catalog_stub"].DeleteTagTemplate + @property def create_tag_template_field(self): """Return the gRPC stub for :meth:`DataCatalogClient.create_tag_template_field`. @@ -492,6 +431,23 @@ def rename_tag_template_field(self): """ return self._stubs["data_catalog_stub"].RenameTagTemplateField + @property + def delete_tag_template_field(self): + """Return the gRPC stub for :meth:`DataCatalogClient.delete_tag_template_field`. + + Deletes a field in a tag template and all uses of that field. Users + should enable the Data Catalog API in the project identified by the + ``name`` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["data_catalog_stub"].DeleteTagTemplateField + @property def create_tag(self): """Return the gRPC stub for :meth:`DataCatalogClient.create_tag`. @@ -523,6 +479,19 @@ def update_tag(self): """ return self._stubs["data_catalog_stub"].UpdateTag + @property + def delete_tag(self): + """Return the gRPC stub for :meth:`DataCatalogClient.delete_tag`. + + Deletes a tag. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["data_catalog_stub"].DeleteTag + @property def list_tags(self): """Return the gRPC stub for :meth:`DataCatalogClient.list_tags`. @@ -564,6 +533,37 @@ def set_iam_policy(self): """ return self._stubs["data_catalog_stub"].SetIamPolicy + @property + def get_iam_policy(self): + """Return the gRPC stub for :meth:`DataCatalogClient.get_iam_policy`. + + Gets the access control policy for a resource. A ``NOT_FOUND`` error + is returned if the resource does not exist. An empty policy is returned + if the resource exists but does not have a policy set on it. + + Supported resources are: + + - Tag templates. + - Entries. + - Entry groups. Note, this method cannot be used to manage policies for + BigQuery, Pub/Sub and any external Google Cloud Platform resources + synced to Data Catalog. + + Callers must have following Google IAM permission + + - ``datacatalog.tagTemplates.getIamPolicy`` to get policies on tag + templates. + - ``datacatalog.entries.getIamPolicy`` to get policies on entries. + - ``datacatalog.entryGroups.getIamPolicy`` to get policies on entry + groups. + + Returns: + Callable: A callable which accepts the appropriate + deserialized request object and returns a + deserialized response object. + """ + return self._stubs["data_catalog_stub"].GetIamPolicy + @property def test_iam_permissions(self): """Return the gRPC stub for :meth:`DataCatalogClient.test_iam_permissions`. diff --git a/google/cloud/datacatalog_v1beta1/proto/common_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/common_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1beta1/proto/common_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/common_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1beta1/proto/datacatalog_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/datacatalog_pb2_grpc.py index e62a806a..4761d635 100644 --- a/google/cloud/datacatalog_v1beta1/proto/datacatalog_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/datacatalog_pb2_grpc.py @@ -1,4 +1,5 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc from google.cloud.datacatalog_v1beta1.proto import ( @@ -14,15 +15,15 @@ class DataCatalogStub(object): """Data Catalog API service allows clients to discover, understand, and manage - their data. - """ + their data. + """ def __init__(self, channel): """Constructor. - Args: - channel: A grpc.Channel. - """ + Args: + channel: A grpc.Channel. + """ self.SearchCatalog = channel.unary_unary( "/google.cloud.datacatalog.v1beta1.DataCatalog/SearchCatalog", request_serializer=google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.SearchCatalogRequest.SerializeToString, @@ -162,319 +163,319 @@ def __init__(self, channel): class DataCatalogServicer(object): """Data Catalog API service allows clients to discover, understand, and manage - their data. - """ + their data. + """ def SearchCatalog(self, request, context): """Searches Data Catalog for multiple resources like entries, tags that - match a query. + match a query. - This is a custom method - (https://cloud.google.com/apis/design/custom_methods) and does not return - the complete resource, only the resource identifier and high level - fields. Clients can subsequentally call `Get` methods. + This is a custom method + (https://cloud.google.com/apis/design/custom_methods) and does not return + the complete resource, only the resource identifier and high level + fields. Clients can subsequentally call `Get` methods. - Note that Data Catalog search queries do not guarantee full recall. Query - results that match your query may not be returned, even in subsequent - result pages. Also note that results returned (and not returned) can vary - across repeated search queries. + Note that Data Catalog search queries do not guarantee full recall. Query + results that match your query may not be returned, even in subsequent + result pages. Also note that results returned (and not returned) can vary + across repeated search queries. - See [Data Catalog Search - Syntax](https://cloud.google.com/data-catalog/docs/how-to/search-reference) - for more information. - """ + See [Data Catalog Search + Syntax](https://cloud.google.com/data-catalog/docs/how-to/search-reference) + for more information. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateEntryGroup(self, request, context): """A maximum of 10,000 entry groups may be created per organization across all - locations. + locations. - Users should enable the Data Catalog API in the project identified by - the `parent` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + Users should enable the Data Catalog API in the project identified by + the `parent` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateEntryGroup(self, request, context): """Updates an EntryGroup. The user should enable the Data Catalog API in the - project identified by the `entry_group.name` parameter (see [Data Catalog - Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + project identified by the `entry_group.name` parameter (see [Data Catalog + Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetEntryGroup(self, request, context): """Gets an EntryGroup. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteEntryGroup(self, request, context): """Deletes an EntryGroup. Only entry groups that do not contain entries can be - deleted. Users should enable the Data Catalog API in the project - identified by the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + deleted. Users should enable the Data Catalog API in the project + identified by the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def ListEntryGroups(self, request, context): """Lists entry groups. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateEntry(self, request, context): """Creates an entry. Only entries of 'FILESET' type or user-specified type can - be created. + be created. - Users should enable the Data Catalog API in the project identified by - the `parent` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). + Users should enable the Data Catalog API in the project identified by + the `parent` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). - A maximum of 100,000 entries may be created per entry group. - """ + A maximum of 100,000 entries may be created per entry group. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateEntry(self, request, context): """Updates an existing entry. - Users should enable the Data Catalog API in the project identified by - the `entry.name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + Users should enable the Data Catalog API in the project identified by + the `entry.name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteEntry(self, request, context): """Deletes an existing entry. Only entries created through - [CreateEntry][google.cloud.datacatalog.v1beta1.DataCatalog.CreateEntry] - method can be deleted. - Users should enable the Data Catalog API in the project identified by - the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + [CreateEntry][google.cloud.datacatalog.v1beta1.DataCatalog.CreateEntry] + method can be deleted. + Users should enable the Data Catalog API in the project identified by + the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetEntry(self, request, context): """Gets an entry. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def LookupEntry(self, request, context): """Get an entry by target resource name. This method allows clients to use - the resource name from the source Google Cloud Platform service to get the - Data Catalog Entry. - """ + the resource name from the source Google Cloud Platform service to get the + Data Catalog Entry. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def ListEntries(self, request, context): """Lists entries. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateTagTemplate(self, request, context): """Creates a tag template. The user should enable the Data Catalog API in - the project identified by the `parent` parameter (see [Data Catalog - Resource - Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - """ + the project identified by the `parent` parameter (see [Data Catalog + Resource + Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetTagTemplate(self, request, context): """Gets a tag template. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateTagTemplate(self, request, context): """Updates a tag template. This method cannot be used to update the fields of - a template. The tag template fields are represented as separate resources - and should be updated using their own create/update/delete methods. - Users should enable the Data Catalog API in the project identified by - the `tag_template.name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + a template. The tag template fields are represented as separate resources + and should be updated using their own create/update/delete methods. + Users should enable the Data Catalog API in the project identified by + the `tag_template.name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteTagTemplate(self, request, context): """Deletes a tag template and all tags using the template. - Users should enable the Data Catalog API in the project identified by - the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + Users should enable the Data Catalog API in the project identified by + the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateTagTemplateField(self, request, context): """Creates a field in a tag template. The user should enable the Data Catalog - API in the project identified by the `parent` parameter (see - [Data Catalog Resource - Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - """ + API in the project identified by the `parent` parameter (see + [Data Catalog Resource + Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateTagTemplateField(self, request, context): """Updates a field in a tag template. This method cannot be used to update the - field type. Users should enable the Data Catalog API in the project - identified by the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + field type. Users should enable the Data Catalog API in the project + identified by the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def RenameTagTemplateField(self, request, context): """Renames a field in a tag template. The user should enable the Data Catalog - API in the project identified by the `name` parameter (see [Data Catalog - Resource - Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) - for more information). - """ + API in the project identified by the `name` parameter (see [Data Catalog + Resource + Project](https://cloud.google.com/data-catalog/docs/concepts/resource-project) + for more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteTagTemplateField(self, request, context): """Deletes a field in a tag template and all uses of that field. - Users should enable the Data Catalog API in the project identified by - the `name` parameter (see [Data Catalog Resource Project] - (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for - more information). - """ + Users should enable the Data Catalog API in the project identified by + the `name` parameter (see [Data Catalog Resource Project] + (https://cloud.google.com/data-catalog/docs/concepts/resource-project) for + more information). + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreateTag(self, request, context): """Creates a tag on an [Entry][google.cloud.datacatalog.v1beta1.Entry]. - Note: The project identified by the `parent` parameter for the - [tag](https://cloud.google.com/data-catalog/docs/reference/rest/v1beta1/projects.locations.entryGroups.entries.tags/create#path-parameters) - and the - [tag - template](https://cloud.google.com/data-catalog/docs/reference/rest/v1beta1/projects.locations.tagTemplates/create#path-parameters) - used to create the tag must be from the same organization. - """ + Note: The project identified by the `parent` parameter for the + [tag](https://cloud.google.com/data-catalog/docs/reference/rest/v1beta1/projects.locations.entryGroups.entries.tags/create#path-parameters) + and the + [tag + template](https://cloud.google.com/data-catalog/docs/reference/rest/v1beta1/projects.locations.tagTemplates/create#path-parameters) + used to create the tag must be from the same organization. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateTag(self, request, context): """Updates an existing tag. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteTag(self, request, context): """Deletes a tag. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def ListTags(self, request, context): """Lists the tags on an [Entry][google.cloud.datacatalog.v1beta1.Entry]. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def SetIamPolicy(self, request, context): """Sets the access control policy for a resource. Replaces any existing - policy. - Supported resources are: - - Tag templates. - - Entries. - - Entry groups. - Note, this method cannot be used to manage policies for BigQuery, Pub/Sub - and any external Google Cloud Platform resources synced to Data Catalog. - - Callers must have following Google IAM permission - - `datacatalog.tagTemplates.setIamPolicy` to set policies on tag - templates. - - `datacatalog.entries.setIamPolicy` to set policies on entries. - - `datacatalog.entryGroups.setIamPolicy` to set policies on entry groups. - """ + policy. + Supported resources are: + - Tag templates. + - Entries. + - Entry groups. + Note, this method cannot be used to manage policies for BigQuery, Pub/Sub + and any external Google Cloud Platform resources synced to Data Catalog. + + Callers must have following Google IAM permission + - `datacatalog.tagTemplates.setIamPolicy` to set policies on tag + templates. + - `datacatalog.entries.setIamPolicy` to set policies on entries. + - `datacatalog.entryGroups.setIamPolicy` to set policies on entry groups. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetIamPolicy(self, request, context): """Gets the access control policy for a resource. A `NOT_FOUND` error - is returned if the resource does not exist. An empty policy is returned - if the resource exists but does not have a policy set on it. - - Supported resources are: - - Tag templates. - - Entries. - - Entry groups. - Note, this method cannot be used to manage policies for BigQuery, Pub/Sub - and any external Google Cloud Platform resources synced to Data Catalog. - - Callers must have following Google IAM permission - - `datacatalog.tagTemplates.getIamPolicy` to get policies on tag - templates. - - `datacatalog.entries.getIamPolicy` to get policies on entries. - - `datacatalog.entryGroups.getIamPolicy` to get policies on entry groups. - """ + is returned if the resource does not exist. An empty policy is returned + if the resource exists but does not have a policy set on it. + + Supported resources are: + - Tag templates. + - Entries. + - Entry groups. + Note, this method cannot be used to manage policies for BigQuery, Pub/Sub + and any external Google Cloud Platform resources synced to Data Catalog. + + Callers must have following Google IAM permission + - `datacatalog.tagTemplates.getIamPolicy` to get policies on tag + templates. + - `datacatalog.entries.getIamPolicy` to get policies on entries. + - `datacatalog.entryGroups.getIamPolicy` to get policies on entry groups. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def TestIamPermissions(self, request, context): """Returns the caller's permissions on a resource. - If the resource does not exist, an empty set of permissions is returned - (We don't return a `NOT_FOUND` error). - - Supported resources are: - - Tag templates. - - Entries. - - Entry groups. - Note, this method cannot be used to manage policies for BigQuery, Pub/Sub - and any external Google Cloud Platform resources synced to Data Catalog. - - A caller is not required to have Google IAM permission to make this - request. - """ + If the resource does not exist, an empty set of permissions is returned + (We don't return a `NOT_FOUND` error). + + Supported resources are: + - Tag templates. + - Entries. + - Entry groups. + Note, this method cannot be used to manage policies for BigQuery, Pub/Sub + and any external Google Cloud Platform resources synced to Data Catalog. + + A caller is not required to have Google IAM permission to make this + request. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") @@ -622,3 +623,739 @@ def add_DataCatalogServicer_to_server(servicer, server): "google.cloud.datacatalog.v1beta1.DataCatalog", rpc_method_handlers ) server.add_generic_rpc_handlers((generic_handler,)) + + +# This class is part of an EXPERIMENTAL API. +class DataCatalog(object): + """Data Catalog API service allows clients to discover, understand, and manage + their data. + """ + + @staticmethod + def SearchCatalog( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/SearchCatalog", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.SearchCatalogRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.SearchCatalogResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateEntryGroup( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/CreateEntryGroup", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.CreateEntryGroupRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.EntryGroup.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateEntryGroup( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/UpdateEntryGroup", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.UpdateEntryGroupRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.EntryGroup.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetEntryGroup( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/GetEntryGroup", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.GetEntryGroupRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.EntryGroup.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteEntryGroup( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/DeleteEntryGroup", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.DeleteEntryGroupRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListEntryGroups( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/ListEntryGroups", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.ListEntryGroupsRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.ListEntryGroupsResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/CreateEntry", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.CreateEntryRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.Entry.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/UpdateEntry", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.UpdateEntryRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.Entry.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/DeleteEntry", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.DeleteEntryRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/GetEntry", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.GetEntryRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.Entry.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def LookupEntry( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/LookupEntry", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.LookupEntryRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.Entry.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListEntries( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/ListEntries", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.ListEntriesRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.ListEntriesResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateTagTemplate( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/CreateTagTemplate", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.CreateTagTemplateRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_tags__pb2.TagTemplate.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetTagTemplate( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/GetTagTemplate", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.GetTagTemplateRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_tags__pb2.TagTemplate.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateTagTemplate( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/UpdateTagTemplate", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.UpdateTagTemplateRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_tags__pb2.TagTemplate.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteTagTemplate( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/DeleteTagTemplate", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.DeleteTagTemplateRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateTagTemplateField( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/CreateTagTemplateField", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.CreateTagTemplateFieldRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_tags__pb2.TagTemplateField.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateTagTemplateField( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/UpdateTagTemplateField", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.UpdateTagTemplateFieldRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_tags__pb2.TagTemplateField.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def RenameTagTemplateField( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/RenameTagTemplateField", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.RenameTagTemplateFieldRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_tags__pb2.TagTemplateField.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteTagTemplateField( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/DeleteTagTemplateField", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.DeleteTagTemplateFieldRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreateTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/CreateTag", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.CreateTagRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_tags__pb2.Tag.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/UpdateTag", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.UpdateTagRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_tags__pb2.Tag.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/DeleteTag", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.DeleteTagRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListTags( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/ListTags", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.ListTagsRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_datacatalog__pb2.ListTagsResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def SetIamPolicy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/SetIamPolicy", + google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.SerializeToString, + google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetIamPolicy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/GetIamPolicy", + google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.SerializeToString, + google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def TestIamPermissions( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.DataCatalog/TestIamPermissions", + google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.SerializeToString, + google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) diff --git a/google/cloud/datacatalog_v1beta1/proto/gcs_fileset_spec_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/gcs_fileset_spec_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1beta1/proto/gcs_fileset_spec_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/gcs_fileset_spec_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1beta1/proto/policytagmanager_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/policytagmanager_pb2_grpc.py index 4f6c48e6..45ac67be 100644 --- a/google/cloud/datacatalog_v1beta1/proto/policytagmanager_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/policytagmanager_pb2_grpc.py @@ -1,4 +1,5 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc from google.cloud.datacatalog_v1beta1.proto import ( @@ -11,15 +12,15 @@ class PolicyTagManagerStub(object): """The policy tag manager API service allows clients to manage their taxonomies - and policy tags. - """ + and policy tags. + """ def __init__(self, channel): """Constructor. - Args: - channel: A grpc.Channel. - """ + Args: + channel: A grpc.Channel. + """ self.CreateTaxonomy = channel.unary_unary( "/google.cloud.datacatalog.v1beta1.PolicyTagManager/CreateTaxonomy", request_serializer=google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.CreateTaxonomyRequest.SerializeToString, @@ -89,99 +90,99 @@ def __init__(self, channel): class PolicyTagManagerServicer(object): """The policy tag manager API service allows clients to manage their taxonomies - and policy tags. - """ + and policy tags. + """ def CreateTaxonomy(self, request, context): """Creates a taxonomy in the specified project. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeleteTaxonomy(self, request, context): """Deletes a taxonomy. This operation will also delete all - policy tags in this taxonomy along with their associated policies. - """ + policy tags in this taxonomy along with their associated policies. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdateTaxonomy(self, request, context): """Updates a taxonomy. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def ListTaxonomies(self, request, context): """Lists all taxonomies in a project in a particular location that the caller - has permission to view. - """ + has permission to view. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetTaxonomy(self, request, context): """Gets a taxonomy. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def CreatePolicyTag(self, request, context): """Creates a policy tag in the specified taxonomy. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def DeletePolicyTag(self, request, context): """Deletes a policy tag. Also deletes all of its descendant policy tags. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def UpdatePolicyTag(self, request, context): """Updates a policy tag. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def ListPolicyTags(self, request, context): """Lists all policy tags in a taxonomy. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetPolicyTag(self, request, context): """Gets a policy tag. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def GetIamPolicy(self, request, context): """Gets the IAM policy for a taxonomy or a policy tag. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def SetIamPolicy(self, request, context): """Sets the IAM policy for a taxonomy or a policy tag. - """ + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") def TestIamPermissions(self, request, context): """Returns the permissions that a caller has on the specified taxonomy or - policy tag. - """ + policy tag. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") @@ -259,3 +260,361 @@ def add_PolicyTagManagerServicer_to_server(servicer, server): "google.cloud.datacatalog.v1beta1.PolicyTagManager", rpc_method_handlers ) server.add_generic_rpc_handlers((generic_handler,)) + + +# This class is part of an EXPERIMENTAL API. +class PolicyTagManager(object): + """The policy tag manager API service allows clients to manage their taxonomies + and policy tags. + """ + + @staticmethod + def CreateTaxonomy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/CreateTaxonomy", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.CreateTaxonomyRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.Taxonomy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeleteTaxonomy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/DeleteTaxonomy", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.DeleteTaxonomyRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdateTaxonomy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/UpdateTaxonomy", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.UpdateTaxonomyRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.Taxonomy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListTaxonomies( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/ListTaxonomies", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.ListTaxonomiesRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.ListTaxonomiesResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetTaxonomy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/GetTaxonomy", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.GetTaxonomyRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.Taxonomy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def CreatePolicyTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/CreatePolicyTag", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.CreatePolicyTagRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.PolicyTag.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def DeletePolicyTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/DeletePolicyTag", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.DeletePolicyTagRequest.SerializeToString, + google_dot_protobuf_dot_empty__pb2.Empty.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def UpdatePolicyTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/UpdatePolicyTag", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.UpdatePolicyTagRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.PolicyTag.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ListPolicyTags( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/ListPolicyTags", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.ListPolicyTagsRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.ListPolicyTagsResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetPolicyTag( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/GetPolicyTag", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.GetPolicyTagRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanager__pb2.PolicyTag.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def GetIamPolicy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/GetIamPolicy", + google_dot_iam_dot_v1_dot_iam__policy__pb2.GetIamPolicyRequest.SerializeToString, + google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def SetIamPolicy( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/SetIamPolicy", + google_dot_iam_dot_v1_dot_iam__policy__pb2.SetIamPolicyRequest.SerializeToString, + google_dot_iam_dot_v1_dot_policy__pb2.Policy.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def TestIamPermissions( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManager/TestIamPermissions", + google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsRequest.SerializeToString, + google_dot_iam_dot_v1_dot_iam__policy__pb2.TestIamPermissionsResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) diff --git a/google/cloud/datacatalog_v1beta1/proto/policytagmanagerserialization_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/policytagmanagerserialization_pb2_grpc.py index 74a7fdcf..1d06f122 100644 --- a/google/cloud/datacatalog_v1beta1/proto/policytagmanagerserialization_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/policytagmanagerserialization_pb2_grpc.py @@ -1,4 +1,5 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc from google.cloud.datacatalog_v1beta1.proto import ( @@ -8,15 +9,15 @@ class PolicyTagManagerSerializationStub(object): """Policy tag manager serialization API service allows clients to manipulate - their taxonomies and policy tags data with serialized format. - """ + their taxonomies and policy tags data with serialized format. + """ def __init__(self, channel): """Constructor. - Args: - channel: A grpc.Channel. - """ + Args: + channel: A grpc.Channel. + """ self.ImportTaxonomies = channel.unary_unary( "/google.cloud.datacatalog.v1beta1.PolicyTagManagerSerialization/ImportTaxonomies", request_serializer=google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanagerserialization__pb2.ImportTaxonomiesRequest.SerializeToString, @@ -31,16 +32,16 @@ def __init__(self, channel): class PolicyTagManagerSerializationServicer(object): """Policy tag manager serialization API service allows clients to manipulate - their taxonomies and policy tags data with serialized format. - """ + their taxonomies and policy tags data with serialized format. + """ def ImportTaxonomies(self, request, context): """Imports all taxonomies and their policy tags to a project as new - taxonomies. + taxonomies. - This method provides a bulk taxonomy / policy tag creation using nested - proto structure. - """ + This method provides a bulk taxonomy / policy tag creation using nested + proto structure. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") @@ -48,9 +49,9 @@ def ImportTaxonomies(self, request, context): def ExportTaxonomies(self, request, context): """Exports all taxonomies and their policy tags in a project. - This method generates SerializedTaxonomy protos with nested policy tags - that can be used as an input for future ImportTaxonomies calls. - """ + This method generates SerializedTaxonomy protos with nested policy tags + that can be used as an input for future ImportTaxonomies calls. + """ context.set_code(grpc.StatusCode.UNIMPLEMENTED) context.set_details("Method not implemented!") raise NotImplementedError("Method not implemented!") @@ -74,3 +75,64 @@ def add_PolicyTagManagerSerializationServicer_to_server(servicer, server): rpc_method_handlers, ) server.add_generic_rpc_handlers((generic_handler,)) + + +# This class is part of an EXPERIMENTAL API. +class PolicyTagManagerSerialization(object): + """Policy tag manager serialization API service allows clients to manipulate + their taxonomies and policy tags data with serialized format. + """ + + @staticmethod + def ImportTaxonomies( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManagerSerialization/ImportTaxonomies", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanagerserialization__pb2.ImportTaxonomiesRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanagerserialization__pb2.ImportTaxonomiesResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) + + @staticmethod + def ExportTaxonomies( + request, + target, + options=(), + channel_credentials=None, + call_credentials=None, + compression=None, + wait_for_ready=None, + timeout=None, + metadata=None, + ): + return grpc.experimental.unary_unary( + request, + target, + "/google.cloud.datacatalog.v1beta1.PolicyTagManagerSerialization/ExportTaxonomies", + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanagerserialization__pb2.ExportTaxonomiesRequest.SerializeToString, + google_dot_cloud_dot_datacatalog__v1beta1_dot_proto_dot_policytagmanagerserialization__pb2.ExportTaxonomiesResponse.FromString, + options, + channel_credentials, + call_credentials, + compression, + wait_for_ready, + timeout, + metadata, + ) diff --git a/google/cloud/datacatalog_v1beta1/proto/schema_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/schema_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1beta1/proto/schema_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/schema_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1beta1/proto/search_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/search_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1beta1/proto/search_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/search_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1beta1/proto/table_spec_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/table_spec_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1beta1/proto/table_spec_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/table_spec_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1beta1/proto/tags_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/tags_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1beta1/proto/tags_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/tags_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/google/cloud/datacatalog_v1beta1/proto/timestamps_pb2_grpc.py b/google/cloud/datacatalog_v1beta1/proto/timestamps_pb2_grpc.py index 07cb78fe..8a939394 100644 --- a/google/cloud/datacatalog_v1beta1/proto/timestamps_pb2_grpc.py +++ b/google/cloud/datacatalog_v1beta1/proto/timestamps_pb2_grpc.py @@ -1,2 +1,3 @@ # Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT! +"""Client and server classes corresponding to protobuf-defined services.""" import grpc diff --git a/synth.metadata b/synth.metadata index 22af2a36..11d4ab10 100644 --- a/synth.metadata +++ b/synth.metadata @@ -4,15 +4,15 @@ "git": { "name": ".", "remote": "https://github.com/googleapis/python-datacatalog.git", - "sha": "0b9167c0533fefd800021987aabdc42acd8d5293" + "sha": "a952553639d399ba66de422fcbb63af43a7f54b4" } }, { "git": { "name": "googleapis", "remote": "https://github.com/googleapis/googleapis.git", - "sha": "184661793fbe3b89f2b485c303e7466cef9d21a1", - "internalRef": "316182409" + "sha": "db69b46790b55a82ab7cfa473d031da787bc7591", + "internalRef": "320411362" } }, { diff --git a/tests/unit/gapic/v1beta1/test_data_catalog_client_v1beta1.py b/tests/unit/gapic/v1beta1/test_data_catalog_client_v1beta1.py index fd900fd1..9c04c196 100644 --- a/tests/unit/gapic/v1beta1/test_data_catalog_client_v1beta1.py +++ b/tests/unit/gapic/v1beta1/test_data_catalog_client_v1beta1.py @@ -112,68 +112,6 @@ def test_search_catalog_exception(self): with pytest.raises(CustomException): list(paged_list_response) - def test_delete_entry_group(self): - channel = ChannelStub() - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup Request - name = client.entry_group_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]") - - client.delete_entry_group(name) - - assert len(channel.requests) == 1 - expected_request = datacatalog_pb2.DeleteEntryGroupRequest(name=name) - actual_request = channel.requests[0][1] - assert expected_request == actual_request - - def test_delete_entry_group_exception(self): - # Mock the API response - channel = ChannelStub(responses=[CustomException()]) - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup request - name = client.entry_group_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]") - - with pytest.raises(CustomException): - client.delete_entry_group(name) - - def test_delete_entry(self): - channel = ChannelStub() - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup Request - name = client.entry_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]") - - client.delete_entry(name) - - assert len(channel.requests) == 1 - expected_request = datacatalog_pb2.DeleteEntryRequest(name=name) - actual_request = channel.requests[0][1] - assert expected_request == actual_request - - def test_delete_entry_exception(self): - # Mock the API response - channel = ChannelStub(responses=[CustomException()]) - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup request - name = client.entry_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]") - - with pytest.raises(CustomException): - client.delete_entry(name) - def test_get_entry(self): # Setup Expected Response name_2 = "name2-1052831874" @@ -268,150 +206,6 @@ def test_lookup_entry_exception(self): with pytest.raises(CustomException): client.lookup_entry() - def test_delete_tag_template(self): - channel = ChannelStub() - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup Request - name = client.tag_template_path("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]") - force = False - - client.delete_tag_template(name, force) - - assert len(channel.requests) == 1 - expected_request = datacatalog_pb2.DeleteTagTemplateRequest( - name=name, force=force - ) - actual_request = channel.requests[0][1] - assert expected_request == actual_request - - def test_delete_tag_template_exception(self): - # Mock the API response - channel = ChannelStub(responses=[CustomException()]) - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup request - name = client.tag_template_path("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]") - force = False - - with pytest.raises(CustomException): - client.delete_tag_template(name, force) - - def test_delete_tag_template_field(self): - channel = ChannelStub() - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup Request - name = client.tag_template_field_path( - "[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]" - ) - force = False - - client.delete_tag_template_field(name, force) - - assert len(channel.requests) == 1 - expected_request = datacatalog_pb2.DeleteTagTemplateFieldRequest( - name=name, force=force - ) - actual_request = channel.requests[0][1] - assert expected_request == actual_request - - def test_delete_tag_template_field_exception(self): - # Mock the API response - channel = ChannelStub(responses=[CustomException()]) - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup request - name = client.tag_template_field_path( - "[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]" - ) - force = False - - with pytest.raises(CustomException): - client.delete_tag_template_field(name, force) - - def test_delete_tag(self): - channel = ChannelStub() - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup Request - name = client.entry_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]") - - client.delete_tag(name) - - assert len(channel.requests) == 1 - expected_request = datacatalog_pb2.DeleteTagRequest(name=name) - actual_request = channel.requests[0][1] - assert expected_request == actual_request - - def test_delete_tag_exception(self): - # Mock the API response - channel = ChannelStub(responses=[CustomException()]) - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup request - name = client.entry_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]") - - with pytest.raises(CustomException): - client.delete_tag(name) - - def test_get_iam_policy(self): - # Setup Expected Response - version = 351608024 - etag = b"21" - expected_response = {"version": version, "etag": etag} - expected_response = policy_pb2.Policy(**expected_response) - - # Mock the API response - channel = ChannelStub(responses=[expected_response]) - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup Request - resource = "resource-341064690" - - response = client.get_iam_policy(resource) - assert expected_response == response - - assert len(channel.requests) == 1 - expected_request = iam_policy_pb2.GetIamPolicyRequest(resource=resource) - actual_request = channel.requests[0][1] - assert expected_request == actual_request - - def test_get_iam_policy_exception(self): - # Mock the API response - channel = ChannelStub(responses=[CustomException()]) - patch = mock.patch("google.api_core.grpc_helpers.create_channel") - with patch as create_channel: - create_channel.return_value = channel - client = datacatalog_v1beta1.DataCatalogClient() - - # Setup request - resource = "resource-341064690" - - with pytest.raises(CustomException): - client.get_iam_policy(resource) - def test_create_entry_group(self): # Setup Expected Response name = "name3373707" @@ -550,6 +344,37 @@ def test_get_entry_group_exception(self): with pytest.raises(CustomException): client.get_entry_group(name) + def test_delete_entry_group(self): + channel = ChannelStub() + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup Request + name = client.entry_group_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]") + + client.delete_entry_group(name) + + assert len(channel.requests) == 1 + expected_request = datacatalog_pb2.DeleteEntryGroupRequest(name=name) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_delete_entry_group_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup request + name = client.entry_group_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]") + + with pytest.raises(CustomException): + client.delete_entry_group(name) + def test_list_entry_groups(self): # Setup Expected Response next_page_token = "" @@ -702,6 +527,37 @@ def test_update_entry_exception(self): with pytest.raises(CustomException): client.update_entry(entry) + def test_delete_entry(self): + channel = ChannelStub() + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup Request + name = client.entry_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]") + + client.delete_entry(name) + + assert len(channel.requests) == 1 + expected_request = datacatalog_pb2.DeleteEntryRequest(name=name) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_delete_entry_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup request + name = client.entry_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]") + + with pytest.raises(CustomException): + client.delete_entry(name) + def test_list_entries(self): # Setup Expected Response next_page_token = "" @@ -870,6 +726,41 @@ def test_update_tag_template_exception(self): with pytest.raises(CustomException): client.update_tag_template(tag_template) + def test_delete_tag_template(self): + channel = ChannelStub() + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup Request + name = client.tag_template_path("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]") + force = False + + client.delete_tag_template(name, force) + + assert len(channel.requests) == 1 + expected_request = datacatalog_pb2.DeleteTagTemplateRequest( + name=name, force=force + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_delete_tag_template_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup request + name = client.tag_template_path("[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]") + force = False + + with pytest.raises(CustomException): + client.delete_tag_template(name, force) + def test_create_tag_template_field(self): # Setup Expected Response name = "name3373707" @@ -1036,6 +927,45 @@ def test_rename_tag_template_field_exception(self): with pytest.raises(CustomException): client.rename_tag_template_field(name, new_tag_template_field_id) + def test_delete_tag_template_field(self): + channel = ChannelStub() + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup Request + name = client.tag_template_field_path( + "[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]" + ) + force = False + + client.delete_tag_template_field(name, force) + + assert len(channel.requests) == 1 + expected_request = datacatalog_pb2.DeleteTagTemplateFieldRequest( + name=name, force=force + ) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_delete_tag_template_field_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup request + name = client.tag_template_field_path( + "[PROJECT]", "[LOCATION]", "[TAG_TEMPLATE]", "[FIELD]" + ) + force = False + + with pytest.raises(CustomException): + client.delete_tag_template_field(name, force) + def test_create_tag(self): # Setup Expected Response name = "name3373707" @@ -1134,6 +1064,37 @@ def test_update_tag_exception(self): with pytest.raises(CustomException): client.update_tag(tag) + def test_delete_tag(self): + channel = ChannelStub() + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup Request + name = client.entry_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]") + + client.delete_tag(name) + + assert len(channel.requests) == 1 + expected_request = datacatalog_pb2.DeleteTagRequest(name=name) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_delete_tag_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup request + name = client.entry_path("[PROJECT]", "[LOCATION]", "[ENTRY_GROUP]", "[ENTRY]") + + with pytest.raises(CustomException): + client.delete_tag(name) + def test_list_tags(self): # Setup Expected Response next_page_token = "" @@ -1224,6 +1185,45 @@ def test_set_iam_policy_exception(self): with pytest.raises(CustomException): client.set_iam_policy(resource, policy) + def test_get_iam_policy(self): + # Setup Expected Response + version = 351608024 + etag = b"21" + expected_response = {"version": version, "etag": etag} + expected_response = policy_pb2.Policy(**expected_response) + + # Mock the API response + channel = ChannelStub(responses=[expected_response]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup Request + resource = "resource-341064690" + + response = client.get_iam_policy(resource) + assert expected_response == response + + assert len(channel.requests) == 1 + expected_request = iam_policy_pb2.GetIamPolicyRequest(resource=resource) + actual_request = channel.requests[0][1] + assert expected_request == actual_request + + def test_get_iam_policy_exception(self): + # Mock the API response + channel = ChannelStub(responses=[CustomException()]) + patch = mock.patch("google.api_core.grpc_helpers.create_channel") + with patch as create_channel: + create_channel.return_value = channel + client = datacatalog_v1beta1.DataCatalogClient() + + # Setup request + resource = "resource-341064690" + + with pytest.raises(CustomException): + client.get_iam_policy(resource) + def test_test_iam_permissions(self): # Setup Expected Response expected_response = {}