diff --git a/packages/google-area120-tables/google/area120/tables_v1alpha1/services/tables_service/async_client.py b/packages/google-area120-tables/google/area120/tables_v1alpha1/services/tables_service/async_client.py index 744f5e5104ee..e6a023b7bce2 100644 --- a/packages/google-area120-tables/google/area120/tables_v1alpha1/services/tables_service/async_client.py +++ b/packages/google-area120-tables/google/area120/tables_v1alpha1/services/tables_service/async_client.py @@ -232,6 +232,25 @@ async def get_table( ) -> tables.Table: r"""Gets a table. Returns NOT_FOUND if the table does not exist. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_get_table(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetTableRequest( + name="name_value", + ) + + # Make the request + response = client.get_table(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.GetTableRequest, dict]): The request object. Request message for @@ -300,6 +319,23 @@ async def list_tables( ) -> pagers.ListTablesAsyncPager: r"""Lists tables for the user. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_list_tables(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListTablesRequest( + ) + + # Make the request + page_result = client.list_tables(request=request) + for response in page_result: + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.ListTablesRequest, dict]): The request object. Request message for @@ -354,6 +390,26 @@ async def get_workspace( r"""Gets a workspace. Returns NOT_FOUND if the workspace does not exist. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_get_workspace(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetWorkspaceRequest( + name="name_value", + ) + + # Make the request + response = client.get_workspace(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.GetWorkspaceRequest, dict]): The request object. Request message for @@ -423,6 +479,23 @@ async def list_workspaces( ) -> pagers.ListWorkspacesAsyncPager: r"""Lists workspaces for the user. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_list_workspaces(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListWorkspacesRequest( + ) + + # Make the request + page_result = client.list_workspaces(request=request) + for response in page_result: + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.ListWorkspacesRequest, dict]): The request object. Request message for @@ -477,6 +550,26 @@ async def get_row( r"""Gets a row. Returns NOT_FOUND if the row does not exist in the table. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_get_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetRowRequest( + name="name_value", + ) + + # Make the request + response = client.get_row(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.GetRowRequest, dict]): The request object. Request message for @@ -548,6 +641,25 @@ async def list_rows( r"""Lists rows in a table. Returns NOT_FOUND if the table does not exist. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_list_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListRowsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_rows(request=request) + for response in page_result: + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.ListRowsRequest, dict]): The request object. Request message for @@ -629,6 +741,25 @@ async def create_row( ) -> tables.Row: r"""Creates a row. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_create_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.CreateRowRequest( + parent="parent_value", + ) + + # Make the request + response = client.create_row(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.CreateRowRequest, dict]): The request object. Request message for @@ -705,6 +836,29 @@ async def batch_create_rows( ) -> tables.BatchCreateRowsResponse: r"""Creates multiple rows. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_batch_create_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + requests = tables_v1alpha1.CreateRowRequest() + requests.parent = "parent_value" + + request = tables_v1alpha1.BatchCreateRowsRequest( + parent="parent_value", + requests=requests, + ) + + # Make the request + response = client.batch_create_rows(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.BatchCreateRowsRequest, dict]): The request object. Request message for @@ -756,6 +910,24 @@ async def update_row( ) -> tables.Row: r"""Updates a row. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_update_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.UpdateRowRequest( + ) + + # Make the request + response = client.update_row(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.UpdateRowRequest, dict]): The request object. Request message for @@ -829,6 +1001,25 @@ async def batch_update_rows( ) -> tables.BatchUpdateRowsResponse: r"""Updates multiple rows. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_batch_update_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.BatchUpdateRowsRequest( + parent="parent_value", + ) + + # Make the request + response = client.batch_update_rows(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.BatchUpdateRowsRequest, dict]): The request object. Request message for @@ -879,6 +1070,22 @@ async def delete_row( ) -> None: r"""Deletes a row. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_delete_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.DeleteRowRequest( + name="name_value", + ) + + # Make the request + response = client.delete_row(request=request) + Args: request (Union[google.area120.tables_v1alpha1.types.DeleteRowRequest, dict]): The request object. Request message for @@ -943,6 +1150,23 @@ async def batch_delete_rows( ) -> None: r"""Deletes multiple rows. + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_batch_delete_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.BatchDeleteRowsRequest( + parent="parent_value", + names=['names_value_1', 'names_value_2'], + ) + + # Make the request + response = client.batch_delete_rows(request=request) + Args: request (Union[google.area120.tables_v1alpha1.types.BatchDeleteRowsRequest, dict]): The request object. Request message for diff --git a/packages/google-area120-tables/google/area120/tables_v1alpha1/services/tables_service/client.py b/packages/google-area120-tables/google/area120/tables_v1alpha1/services/tables_service/client.py index cd76c29d1270..f0f81c52f5b1 100644 --- a/packages/google-area120-tables/google/area120/tables_v1alpha1/services/tables_service/client.py +++ b/packages/google-area120-tables/google/area120/tables_v1alpha1/services/tables_service/client.py @@ -440,6 +440,26 @@ def get_table( ) -> tables.Table: r"""Gets a table. Returns NOT_FOUND if the table does not exist. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_get_table(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetTableRequest( + name="name_value", + ) + + # Make the request + response = client.get_table(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.GetTableRequest, dict]): The request object. Request message for @@ -508,6 +528,24 @@ def list_tables( ) -> pagers.ListTablesPager: r"""Lists tables for the user. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_list_tables(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListTablesRequest( + ) + + # Make the request + page_result = client.list_tables(request=request) + for response in page_result: + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.ListTablesRequest, dict]): The request object. Request message for @@ -563,6 +601,27 @@ def get_workspace( r"""Gets a workspace. Returns NOT_FOUND if the workspace does not exist. + + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_get_workspace(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetWorkspaceRequest( + name="name_value", + ) + + # Make the request + response = client.get_workspace(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.GetWorkspaceRequest, dict]): The request object. Request message for @@ -632,6 +691,24 @@ def list_workspaces( ) -> pagers.ListWorkspacesPager: r"""Lists workspaces for the user. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_list_workspaces(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListWorkspacesRequest( + ) + + # Make the request + page_result = client.list_workspaces(request=request) + for response in page_result: + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.ListWorkspacesRequest, dict]): The request object. Request message for @@ -687,6 +764,27 @@ def get_row( r"""Gets a row. Returns NOT_FOUND if the row does not exist in the table. + + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_get_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetRowRequest( + name="name_value", + ) + + # Make the request + response = client.get_row(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.GetRowRequest, dict]): The request object. Request message for @@ -758,6 +856,26 @@ def list_rows( r"""Lists rows in a table. Returns NOT_FOUND if the table does not exist. + + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_list_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListRowsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_rows(request=request) + for response in page_result: + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.ListRowsRequest, dict]): The request object. Request message for @@ -839,6 +957,26 @@ def create_row( ) -> tables.Row: r"""Creates a row. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_create_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.CreateRowRequest( + parent="parent_value", + ) + + # Make the request + response = client.create_row(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.CreateRowRequest, dict]): The request object. Request message for @@ -915,6 +1053,30 @@ def batch_create_rows( ) -> tables.BatchCreateRowsResponse: r"""Creates multiple rows. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_batch_create_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + requests = tables_v1alpha1.CreateRowRequest() + requests.parent = "parent_value" + + request = tables_v1alpha1.BatchCreateRowsRequest( + parent="parent_value", + requests=requests, + ) + + # Make the request + response = client.batch_create_rows(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.BatchCreateRowsRequest, dict]): The request object. Request message for @@ -967,6 +1129,25 @@ def update_row( ) -> tables.Row: r"""Updates a row. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_update_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.UpdateRowRequest( + ) + + # Make the request + response = client.update_row(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.UpdateRowRequest, dict]): The request object. Request message for @@ -1040,6 +1221,26 @@ def batch_update_rows( ) -> tables.BatchUpdateRowsResponse: r"""Updates multiple rows. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_batch_update_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.BatchUpdateRowsRequest( + parent="parent_value", + ) + + # Make the request + response = client.batch_update_rows(request=request) + + # Handle response + print(response) + Args: request (Union[google.area120.tables_v1alpha1.types.BatchUpdateRowsRequest, dict]): The request object. Request message for @@ -1091,6 +1292,23 @@ def delete_row( ) -> None: r"""Deletes a row. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_delete_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.DeleteRowRequest( + name="name_value", + ) + + # Make the request + response = client.delete_row(request=request) + Args: request (Union[google.area120.tables_v1alpha1.types.DeleteRowRequest, dict]): The request object. Request message for @@ -1155,6 +1373,24 @@ def batch_delete_rows( ) -> None: r"""Deletes multiple rows. + + .. code-block:: + + from google.area120 import tables_v1alpha1 + + def sample_batch_delete_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.BatchDeleteRowsRequest( + parent="parent_value", + names=['names_value_1', 'names_value_2'], + ) + + # Make the request + response = client.batch_delete_rows(request=request) + Args: request (Union[google.area120.tables_v1alpha1.types.BatchDeleteRowsRequest, dict]): The request object. Request message for diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_create_rows_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_create_rows_async.py new file mode 100644 index 000000000000..c3bc3489de5c --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_create_rows_async.py @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for BatchCreateRows +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_BatchCreateRows_async] +from google.area120 import tables_v1alpha1 + + +async def sample_batch_create_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + requests = tables_v1alpha1.CreateRowRequest() + requests.parent = "parent_value" + + request = tables_v1alpha1.BatchCreateRowsRequest( + parent="parent_value", + requests=requests, + ) + + # Make the request + response = await client.batch_create_rows(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_BatchCreateRows_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_create_rows_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_create_rows_sync.py new file mode 100644 index 000000000000..d1594143b6cf --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_create_rows_sync.py @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for BatchCreateRows +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_BatchCreateRows_sync] +from google.area120 import tables_v1alpha1 + + +def sample_batch_create_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + requests = tables_v1alpha1.CreateRowRequest() + requests.parent = "parent_value" + + request = tables_v1alpha1.BatchCreateRowsRequest( + parent="parent_value", + requests=requests, + ) + + # Make the request + response = client.batch_create_rows(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_BatchCreateRows_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_delete_rows_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_delete_rows_async.py new file mode 100644 index 000000000000..6682fc1ca57e --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_delete_rows_async.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for BatchDeleteRows +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_BatchDeleteRows_async] +from google.area120 import tables_v1alpha1 + + +async def sample_batch_delete_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.BatchDeleteRowsRequest( + parent="parent_value", + names=['names_value_1', 'names_value_2'], + ) + + # Make the request + response = await client.batch_delete_rows(request=request) + + +# [END area120tables_generated_tables_v1alpha1_TablesService_BatchDeleteRows_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_delete_rows_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_delete_rows_sync.py new file mode 100644 index 000000000000..4efa8509f93d --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_delete_rows_sync.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for BatchDeleteRows +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_BatchDeleteRows_sync] +from google.area120 import tables_v1alpha1 + + +def sample_batch_delete_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.BatchDeleteRowsRequest( + parent="parent_value", + names=['names_value_1', 'names_value_2'], + ) + + # Make the request + response = client.batch_delete_rows(request=request) + + +# [END area120tables_generated_tables_v1alpha1_TablesService_BatchDeleteRows_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_update_rows_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_update_rows_async.py new file mode 100644 index 000000000000..e1c0719c533b --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_update_rows_async.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for BatchUpdateRows +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_BatchUpdateRows_async] +from google.area120 import tables_v1alpha1 + + +async def sample_batch_update_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.BatchUpdateRowsRequest( + parent="parent_value", + ) + + # Make the request + response = await client.batch_update_rows(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_BatchUpdateRows_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_update_rows_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_update_rows_sync.py new file mode 100644 index 000000000000..938a0e898479 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_batch_update_rows_sync.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for BatchUpdateRows +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_BatchUpdateRows_sync] +from google.area120 import tables_v1alpha1 + + +def sample_batch_update_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.BatchUpdateRowsRequest( + parent="parent_value", + ) + + # Make the request + response = client.batch_update_rows(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_BatchUpdateRows_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_create_row_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_create_row_async.py new file mode 100644 index 000000000000..ed3f4d92c1ac --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_create_row_async.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateRow +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_CreateRow_async] +from google.area120 import tables_v1alpha1 + + +async def sample_create_row(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.CreateRowRequest( + parent="parent_value", + ) + + # Make the request + response = await client.create_row(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_CreateRow_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_create_row_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_create_row_sync.py new file mode 100644 index 000000000000..e0361909532a --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_create_row_sync.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for CreateRow +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_CreateRow_sync] +from google.area120 import tables_v1alpha1 + + +def sample_create_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.CreateRowRequest( + parent="parent_value", + ) + + # Make the request + response = client.create_row(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_CreateRow_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_delete_row_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_delete_row_async.py new file mode 100644 index 000000000000..9cd01c189a73 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_delete_row_async.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteRow +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_DeleteRow_async] +from google.area120 import tables_v1alpha1 + + +async def sample_delete_row(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.DeleteRowRequest( + name="name_value", + ) + + # Make the request + response = await client.delete_row(request=request) + + +# [END area120tables_generated_tables_v1alpha1_TablesService_DeleteRow_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_delete_row_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_delete_row_sync.py new file mode 100644 index 000000000000..30a4b0dc1e80 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_delete_row_sync.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteRow +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_DeleteRow_sync] +from google.area120 import tables_v1alpha1 + + +def sample_delete_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.DeleteRowRequest( + name="name_value", + ) + + # Make the request + response = client.delete_row(request=request) + + +# [END area120tables_generated_tables_v1alpha1_TablesService_DeleteRow_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_row_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_row_async.py new file mode 100644 index 000000000000..b147d0992d19 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_row_async.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetRow +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_GetRow_async] +from google.area120 import tables_v1alpha1 + + +async def sample_get_row(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetRowRequest( + name="name_value", + ) + + # Make the request + response = await client.get_row(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_GetRow_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_row_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_row_sync.py new file mode 100644 index 000000000000..ed6ed0224c4e --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_row_sync.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetRow +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_GetRow_sync] +from google.area120 import tables_v1alpha1 + + +def sample_get_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetRowRequest( + name="name_value", + ) + + # Make the request + response = client.get_row(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_GetRow_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_table_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_table_async.py new file mode 100644 index 000000000000..54ebf1aabca6 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_table_async.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetTable +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_GetTable_async] +from google.area120 import tables_v1alpha1 + + +async def sample_get_table(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetTableRequest( + name="name_value", + ) + + # Make the request + response = await client.get_table(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_GetTable_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_table_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_table_sync.py new file mode 100644 index 000000000000..7382e6138988 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_table_sync.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetTable +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_GetTable_sync] +from google.area120 import tables_v1alpha1 + + +def sample_get_table(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetTableRequest( + name="name_value", + ) + + # Make the request + response = client.get_table(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_GetTable_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_workspace_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_workspace_async.py new file mode 100644 index 000000000000..6a886a1f829f --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_workspace_async.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetWorkspace +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_GetWorkspace_async] +from google.area120 import tables_v1alpha1 + + +async def sample_get_workspace(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetWorkspaceRequest( + name="name_value", + ) + + # Make the request + response = await client.get_workspace(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_GetWorkspace_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_workspace_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_workspace_sync.py new file mode 100644 index 000000000000..4b6f3d2c498c --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_get_workspace_sync.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for GetWorkspace +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_GetWorkspace_sync] +from google.area120 import tables_v1alpha1 + + +def sample_get_workspace(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.GetWorkspaceRequest( + name="name_value", + ) + + # Make the request + response = client.get_workspace(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_GetWorkspace_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_rows_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_rows_async.py new file mode 100644 index 000000000000..132df1db183c --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_rows_async.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListRows +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_ListRows_async] +from google.area120 import tables_v1alpha1 + + +async def sample_list_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListRowsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_rows(request=request) + async for response in page_result: + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_ListRows_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_rows_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_rows_sync.py new file mode 100644 index 000000000000..43d0b64a20b3 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_rows_sync.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListRows +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_ListRows_sync] +from google.area120 import tables_v1alpha1 + + +def sample_list_rows(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListRowsRequest( + parent="parent_value", + ) + + # Make the request + page_result = client.list_rows(request=request) + for response in page_result: + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_ListRows_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_tables_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_tables_async.py new file mode 100644 index 000000000000..22dfb66e3704 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_tables_async.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListTables +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_ListTables_async] +from google.area120 import tables_v1alpha1 + + +async def sample_list_tables(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListTablesRequest( + ) + + # Make the request + page_result = client.list_tables(request=request) + async for response in page_result: + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_ListTables_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_tables_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_tables_sync.py new file mode 100644 index 000000000000..d21574547759 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_tables_sync.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListTables +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_ListTables_sync] +from google.area120 import tables_v1alpha1 + + +def sample_list_tables(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListTablesRequest( + ) + + # Make the request + page_result = client.list_tables(request=request) + for response in page_result: + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_ListTables_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_workspaces_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_workspaces_async.py new file mode 100644 index 000000000000..2f8e9aef4697 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_workspaces_async.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListWorkspaces +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_ListWorkspaces_async] +from google.area120 import tables_v1alpha1 + + +async def sample_list_workspaces(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListWorkspacesRequest( + ) + + # Make the request + page_result = client.list_workspaces(request=request) + async for response in page_result: + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_ListWorkspaces_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_workspaces_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_workspaces_sync.py new file mode 100644 index 000000000000..1cc50122a923 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_list_workspaces_sync.py @@ -0,0 +1,43 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for ListWorkspaces +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_ListWorkspaces_sync] +from google.area120 import tables_v1alpha1 + + +def sample_list_workspaces(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.ListWorkspacesRequest( + ) + + # Make the request + page_result = client.list_workspaces(request=request) + for response in page_result: + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_ListWorkspaces_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_update_row_async.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_update_row_async.py new file mode 100644 index 000000000000..6537e803a379 --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_update_row_async.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateRow +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_UpdateRow_async] +from google.area120 import tables_v1alpha1 + + +async def sample_update_row(): + # Create a client + client = tables_v1alpha1.TablesServiceAsyncClient() + + # Initialize request argument(s) + request = tables_v1alpha1.UpdateRowRequest( + ) + + # Make the request + response = await client.update_row(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_UpdateRow_async] diff --git a/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_update_row_sync.py b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_update_row_sync.py new file mode 100644 index 000000000000..92f9173c2b0a --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/area120tables_generated_tables_v1alpha1_tables_service_update_row_sync.py @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for UpdateRow +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-area120-tables + + +# [START area120tables_generated_tables_v1alpha1_TablesService_UpdateRow_sync] +from google.area120 import tables_v1alpha1 + + +def sample_update_row(): + # Create a client + client = tables_v1alpha1.TablesServiceClient() + + # Initialize request argument(s) + request = tables_v1alpha1.UpdateRowRequest( + ) + + # Make the request + response = client.update_row(request=request) + + # Handle response + print(response) + +# [END area120tables_generated_tables_v1alpha1_TablesService_UpdateRow_sync] diff --git a/packages/google-area120-tables/samples/generated_samples/snippet_metadata_tables_v1alpha1.json b/packages/google-area120-tables/samples/generated_samples/snippet_metadata_tables_v1alpha1.json new file mode 100644 index 000000000000..a98176fbf9fb --- /dev/null +++ b/packages/google-area120-tables/samples/generated_samples/snippet_metadata_tables_v1alpha1.json @@ -0,0 +1,1052 @@ +{ + "snippets": [ + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "BatchCreateRows" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_batch_create_rows_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_BatchCreateRows_async", + "segments": [ + { + "end": 48, + "start": 27, + "type": "FULL" + }, + { + "end": 48, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 42, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 45, + "start": 43, + "type": "REQUEST_EXECUTION" + }, + { + "end": 49, + "start": 46, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "BatchCreateRows" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_batch_create_rows_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_BatchCreateRows_sync", + "segments": [ + { + "end": 48, + "start": 27, + "type": "FULL" + }, + { + "end": 48, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 42, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 45, + "start": 43, + "type": "REQUEST_EXECUTION" + }, + { + "end": 49, + "start": 46, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "BatchDeleteRows" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_batch_delete_rows_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_BatchDeleteRows_async", + "segments": [ + { + "end": 43, + "start": 27, + "type": "FULL" + }, + { + "end": 43, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 39, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 40, + "type": "REQUEST_EXECUTION" + }, + { + "end": 44, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "BatchDeleteRows" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_batch_delete_rows_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_BatchDeleteRows_sync", + "segments": [ + { + "end": 43, + "start": 27, + "type": "FULL" + }, + { + "end": 43, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 39, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 40, + "type": "REQUEST_EXECUTION" + }, + { + "end": 44, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "BatchUpdateRows" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_batch_update_rows_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_BatchUpdateRows_async", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "BatchUpdateRows" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_batch_update_rows_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_BatchUpdateRows_sync", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "CreateRow" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_create_row_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_CreateRow_async", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "CreateRow" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_create_row_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_CreateRow_sync", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "DeleteRow" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_delete_row_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_DeleteRow_async", + "segments": [ + { + "end": 42, + "start": 27, + "type": "FULL" + }, + { + "end": 42, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 43, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "DeleteRow" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_delete_row_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_DeleteRow_sync", + "segments": [ + { + "end": 42, + "start": 27, + "type": "FULL" + }, + { + "end": 42, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 43, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "GetRow" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_get_row_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_GetRow_async", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "GetRow" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_get_row_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_GetRow_sync", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "GetTable" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_get_table_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_GetTable_async", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "GetTable" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_get_table_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_GetTable_sync", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "GetWorkspace" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_get_workspace_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_GetWorkspace_async", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "GetWorkspace" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_get_workspace_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_GetWorkspace_sync", + "segments": [ + { + "end": 44, + "start": 27, + "type": "FULL" + }, + { + "end": 44, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 41, + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 45, + "start": 42, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "ListRows" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_list_rows_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_ListRows_async", + "segments": [ + { + "end": 43, + "start": 27, + "type": "FULL" + }, + { + "end": 43, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 44, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "ListRows" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_list_rows_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_ListRows_sync", + "segments": [ + { + "end": 43, + "start": 27, + "type": "FULL" + }, + { + "end": 43, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 38, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 39, + "type": "REQUEST_EXECUTION" + }, + { + "end": 44, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "ListTables" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_list_tables_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_ListTables_async", + "segments": [ + { + "end": 42, + "start": 27, + "type": "FULL" + }, + { + "end": 42, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 37, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 38, + "type": "REQUEST_EXECUTION" + }, + { + "end": 43, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "ListTables" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_list_tables_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_ListTables_sync", + "segments": [ + { + "end": 42, + "start": 27, + "type": "FULL" + }, + { + "end": 42, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 37, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 38, + "type": "REQUEST_EXECUTION" + }, + { + "end": 43, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "ListWorkspaces" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_list_workspaces_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_ListWorkspaces_async", + "segments": [ + { + "end": 42, + "start": 27, + "type": "FULL" + }, + { + "end": 42, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 37, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 38, + "type": "REQUEST_EXECUTION" + }, + { + "end": 43, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "ListWorkspaces" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_list_workspaces_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_ListWorkspaces_sync", + "segments": [ + { + "end": 42, + "start": 27, + "type": "FULL" + }, + { + "end": 42, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 37, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 38, + "type": "REQUEST_EXECUTION" + }, + { + "end": 43, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "async": true, + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "UpdateRow" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_update_row_async.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_UpdateRow_async", + "segments": [ + { + "end": 43, + "start": 27, + "type": "FULL" + }, + { + "end": 43, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 37, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 40, + "start": 38, + "type": "REQUEST_EXECUTION" + }, + { + "end": 44, + "start": 41, + "type": "RESPONSE_HANDLING" + } + ] + }, + { + "clientMethod": { + "method": { + "service": { + "shortName": "TablesService" + }, + "shortName": "UpdateRow" + } + }, + "file": "area120tables_generated_tables_v1alpha1_tables_service_update_row_sync.py", + "regionTag": "area120tables_generated_tables_v1alpha1_TablesService_UpdateRow_sync", + "segments": [ + { + "end": 43, + "start": 27, + "type": "FULL" + }, + { + "end": 43, + "start": 27, + "type": "SHORT" + }, + { + "end": 33, + "start": 31, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 37, + "start": 34, + "type": "REQUEST_INITIALIZATION" + }, + { + "end": 40, + "start": 38, + "type": "REQUEST_EXECUTION" + }, + { + "end": 44, + "start": 41, + "type": "RESPONSE_HANDLING" + } + ] + } + ] +}