From 79c7efbde4f325300e00e46dd4b2406d97fc1e5e Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Tue, 29 Mar 2022 00:02:19 +0000 Subject: [PATCH 01/19] chore(python): use black==22.3.0 (#81) Source-Link: https://github.com/googleapis/synthtool/commit/6fab84af09f2cf89a031fd8671d1def6b2931b11 Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:7cffbc10910c3ab1b852c05114a08d374c195a81cdec1d4a67a1d129331d0bfe --- .github/.OwlBot.lock.yaml | 2 +- docs/conf.py | 5 +- .../services/controller2/async_client.py | 21 +- .../services/controller2/client.py | 62 +++- .../services/controller2/transports/base.py | 10 +- .../services/controller2/transports/grpc.py | 3 +- .../services/debugger2/async_client.py | 33 ++- .../debugger_v2/services/debugger2/client.py | 74 ++++- .../services/debugger2/transports/base.py | 10 +- .../services/debugger2/transports/grpc.py | 3 +- google/cloud/debugger_v2/types/controller.py | 54 +++- google/cloud/debugger_v2/types/data.py | 237 +++++++++++++--- google/cloud/debugger_v2/types/debugger.py | 134 +++++++-- noxfile.py | 9 +- .../gapic/debugger_v2/test_controller2.py | 210 ++++++++++---- .../unit/gapic/debugger_v2/test_debugger2.py | 264 +++++++++++++----- 16 files changed, 878 insertions(+), 253 deletions(-) diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index 44c78f7..87dd006 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,4 +13,4 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:4e1991042fe54b991db9ca17c8fb386e61b22fe4d1472a568bf0fcac85dcf5d3 + digest: sha256:7cffbc10910c3ab1b852c05114a08d374c195a81cdec1d4a67a1d129331d0bfe diff --git a/docs/conf.py b/docs/conf.py index 8161a89..fef6440 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -361,7 +361,10 @@ intersphinx_mapping = { "python": ("https://python.readthedocs.org/en/latest/", None), "google-auth": ("https://googleapis.dev/python/google-auth/latest/", None), - "google.api_core": ("https://googleapis.dev/python/google-api-core/latest/", None,), + "google.api_core": ( + "https://googleapis.dev/python/google-api-core/latest/", + None, + ), "grpc": ("https://grpc.github.io/grpc/python/", None), "proto-plus": ("https://proto-plus-python.readthedocs.io/en/latest/", None), "protobuf": ("https://googleapis.dev/python/protobuf/latest/", None), diff --git a/google/cloud/debugger_v2/services/controller2/async_client.py b/google/cloud/debugger_v2/services/controller2/async_client.py index c08f317..0a1c4ab 100644 --- a/google/cloud/debugger_v2/services/controller2/async_client.py +++ b/google/cloud/debugger_v2/services/controller2/async_client.py @@ -306,7 +306,12 @@ def sample_register_debuggee(): ) # Send the request. - response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -411,7 +416,12 @@ def sample_list_active_breakpoints(): ) # Send the request. - response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -526,7 +536,12 @@ def sample_update_active_breakpoint(): ) # Send the request. - response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response diff --git a/google/cloud/debugger_v2/services/controller2/client.py b/google/cloud/debugger_v2/services/controller2/client.py index f3914f5..c3cfb1a 100644 --- a/google/cloud/debugger_v2/services/controller2/client.py +++ b/google/cloud/debugger_v2/services/controller2/client.py @@ -53,7 +53,10 @@ class Controller2ClientMeta(type): _transport_registry["grpc"] = Controller2GrpcTransport _transport_registry["grpc_asyncio"] = Controller2GrpcAsyncIOTransport - def get_transport_class(cls, label: str = None,) -> Type[Controller2Transport]: + def get_transport_class( + cls, + label: str = None, + ) -> Type[Controller2Transport]: """Returns an appropriate transport class. Args: @@ -180,7 +183,9 @@ def transport(self) -> Controller2Transport: return self._transport @staticmethod - def common_billing_account_path(billing_account: str,) -> str: + def common_billing_account_path( + billing_account: str, + ) -> str: """Returns a fully-qualified billing_account string.""" return "billingAccounts/{billing_account}".format( billing_account=billing_account, @@ -193,9 +198,13 @@ def parse_common_billing_account_path(path: str) -> Dict[str, str]: return m.groupdict() if m else {} @staticmethod - def common_folder_path(folder: str,) -> str: + def common_folder_path( + folder: str, + ) -> str: """Returns a fully-qualified folder string.""" - return "folders/{folder}".format(folder=folder,) + return "folders/{folder}".format( + folder=folder, + ) @staticmethod def parse_common_folder_path(path: str) -> Dict[str, str]: @@ -204,9 +213,13 @@ def parse_common_folder_path(path: str) -> Dict[str, str]: return m.groupdict() if m else {} @staticmethod - def common_organization_path(organization: str,) -> str: + def common_organization_path( + organization: str, + ) -> str: """Returns a fully-qualified organization string.""" - return "organizations/{organization}".format(organization=organization,) + return "organizations/{organization}".format( + organization=organization, + ) @staticmethod def parse_common_organization_path(path: str) -> Dict[str, str]: @@ -215,9 +228,13 @@ def parse_common_organization_path(path: str) -> Dict[str, str]: return m.groupdict() if m else {} @staticmethod - def common_project_path(project: str,) -> str: + def common_project_path( + project: str, + ) -> str: """Returns a fully-qualified project string.""" - return "projects/{project}".format(project=project,) + return "projects/{project}".format( + project=project, + ) @staticmethod def parse_common_project_path(path: str) -> Dict[str, str]: @@ -226,10 +243,14 @@ def parse_common_project_path(path: str) -> Dict[str, str]: return m.groupdict() if m else {} @staticmethod - def common_location_path(project: str, location: str,) -> str: + def common_location_path( + project: str, + location: str, + ) -> str: """Returns a fully-qualified location string.""" return "projects/{project}/locations/{location}".format( - project=project, location=location, + project=project, + location=location, ) @staticmethod @@ -491,7 +512,12 @@ def sample_register_debuggee(): rpc = self._transport._wrapped_methods[self._transport.register_debuggee] # Send the request. - response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -586,7 +612,12 @@ def sample_list_active_breakpoints(): rpc = self._transport._wrapped_methods[self._transport.list_active_breakpoints] # Send the request. - response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -691,7 +722,12 @@ def sample_update_active_breakpoint(): rpc = self._transport._wrapped_methods[self._transport.update_active_breakpoint] # Send the request. - response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response diff --git a/google/cloud/debugger_v2/services/controller2/transports/base.py b/google/cloud/debugger_v2/services/controller2/transports/base.py index 9d06849..1dce5c2 100644 --- a/google/cloud/debugger_v2/services/controller2/transports/base.py +++ b/google/cloud/debugger_v2/services/controller2/transports/base.py @@ -124,7 +124,9 @@ def _prep_wrapped_messages(self, client_info): # Precompute the wrapped methods. self._wrapped_methods = { self.register_debuggee: gapic_v1.method.wrap_method( - self.register_debuggee, default_timeout=600.0, client_info=client_info, + self.register_debuggee, + default_timeout=600.0, + client_info=client_info, ), self.list_active_breakpoints: gapic_v1.method.wrap_method( self.list_active_breakpoints, @@ -161,9 +163,9 @@ def _prep_wrapped_messages(self, client_info): def close(self): """Closes resources associated with the transport. - .. warning:: - Only call this method if the transport is NOT shared - with other clients - this may cause errors in other clients! + .. warning:: + Only call this method if the transport is NOT shared + with other clients - this may cause errors in other clients! """ raise NotImplementedError() diff --git a/google/cloud/debugger_v2/services/controller2/transports/grpc.py b/google/cloud/debugger_v2/services/controller2/transports/grpc.py index e3756bc..f7a02d9 100644 --- a/google/cloud/debugger_v2/services/controller2/transports/grpc.py +++ b/google/cloud/debugger_v2/services/controller2/transports/grpc.py @@ -245,8 +245,7 @@ def create_channel( @property def grpc_channel(self) -> grpc.Channel: - """Return the channel designed to connect to this service. - """ + """Return the channel designed to connect to this service.""" return self._grpc_channel @property diff --git a/google/cloud/debugger_v2/services/debugger2/async_client.py b/google/cloud/debugger_v2/services/debugger2/async_client.py index 5e15048..31c7b86 100644 --- a/google/cloud/debugger_v2/services/debugger2/async_client.py +++ b/google/cloud/debugger_v2/services/debugger2/async_client.py @@ -305,7 +305,12 @@ def sample_set_breakpoint(): ) # Send the request. - response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -422,7 +427,12 @@ def sample_get_breakpoint(): ) # Send the request. - response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -530,7 +540,10 @@ def sample_delete_breakpoint(): # Send the request. await rpc( - request, retry=retry, timeout=timeout, metadata=metadata, + request, + retry=retry, + timeout=timeout, + metadata=metadata, ) async def list_breakpoints( @@ -631,7 +644,12 @@ def sample_list_breakpoints(): ) # Send the request. - response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -734,7 +752,12 @@ def sample_list_debuggees(): ) # Send the request. - response = await rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response diff --git a/google/cloud/debugger_v2/services/debugger2/client.py b/google/cloud/debugger_v2/services/debugger2/client.py index 2a73d87..eed6811 100644 --- a/google/cloud/debugger_v2/services/debugger2/client.py +++ b/google/cloud/debugger_v2/services/debugger2/client.py @@ -53,7 +53,10 @@ class Debugger2ClientMeta(type): _transport_registry["grpc"] = Debugger2GrpcTransport _transport_registry["grpc_asyncio"] = Debugger2GrpcAsyncIOTransport - def get_transport_class(cls, label: str = None,) -> Type[Debugger2Transport]: + def get_transport_class( + cls, + label: str = None, + ) -> Type[Debugger2Transport]: """Returns an appropriate transport class. Args: @@ -171,7 +174,9 @@ def transport(self) -> Debugger2Transport: return self._transport @staticmethod - def common_billing_account_path(billing_account: str,) -> str: + def common_billing_account_path( + billing_account: str, + ) -> str: """Returns a fully-qualified billing_account string.""" return "billingAccounts/{billing_account}".format( billing_account=billing_account, @@ -184,9 +189,13 @@ def parse_common_billing_account_path(path: str) -> Dict[str, str]: return m.groupdict() if m else {} @staticmethod - def common_folder_path(folder: str,) -> str: + def common_folder_path( + folder: str, + ) -> str: """Returns a fully-qualified folder string.""" - return "folders/{folder}".format(folder=folder,) + return "folders/{folder}".format( + folder=folder, + ) @staticmethod def parse_common_folder_path(path: str) -> Dict[str, str]: @@ -195,9 +204,13 @@ def parse_common_folder_path(path: str) -> Dict[str, str]: return m.groupdict() if m else {} @staticmethod - def common_organization_path(organization: str,) -> str: + def common_organization_path( + organization: str, + ) -> str: """Returns a fully-qualified organization string.""" - return "organizations/{organization}".format(organization=organization,) + return "organizations/{organization}".format( + organization=organization, + ) @staticmethod def parse_common_organization_path(path: str) -> Dict[str, str]: @@ -206,9 +219,13 @@ def parse_common_organization_path(path: str) -> Dict[str, str]: return m.groupdict() if m else {} @staticmethod - def common_project_path(project: str,) -> str: + def common_project_path( + project: str, + ) -> str: """Returns a fully-qualified project string.""" - return "projects/{project}".format(project=project,) + return "projects/{project}".format( + project=project, + ) @staticmethod def parse_common_project_path(path: str) -> Dict[str, str]: @@ -217,10 +234,14 @@ def parse_common_project_path(path: str) -> Dict[str, str]: return m.groupdict() if m else {} @staticmethod - def common_location_path(project: str, location: str,) -> str: + def common_location_path( + project: str, + location: str, + ) -> str: """Returns a fully-qualified location string.""" return "projects/{project}/locations/{location}".format( - project=project, location=location, + project=project, + location=location, ) @staticmethod @@ -492,7 +513,12 @@ def sample_set_breakpoint(): rpc = self._transport._wrapped_methods[self._transport.set_breakpoint] # Send the request. - response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -599,7 +625,12 @@ def sample_get_breakpoint(): rpc = self._transport._wrapped_methods[self._transport.get_breakpoint] # Send the request. - response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -697,7 +728,10 @@ def sample_delete_breakpoint(): # Send the request. rpc( - request, retry=retry, timeout=timeout, metadata=metadata, + request, + retry=retry, + timeout=timeout, + metadata=metadata, ) def list_breakpoints( @@ -788,7 +822,12 @@ def sample_list_breakpoints(): rpc = self._transport._wrapped_methods[self._transport.list_breakpoints] # Send the request. - response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response @@ -881,7 +920,12 @@ def sample_list_debuggees(): rpc = self._transport._wrapped_methods[self._transport.list_debuggees] # Send the request. - response = rpc(request, retry=retry, timeout=timeout, metadata=metadata,) + response = rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) # Done; return the response. return response diff --git a/google/cloud/debugger_v2/services/debugger2/transports/base.py b/google/cloud/debugger_v2/services/debugger2/transports/base.py index c9ce324..dfb1342 100644 --- a/google/cloud/debugger_v2/services/debugger2/transports/base.py +++ b/google/cloud/debugger_v2/services/debugger2/transports/base.py @@ -125,7 +125,9 @@ def _prep_wrapped_messages(self, client_info): # Precompute the wrapped methods. self._wrapped_methods = { self.set_breakpoint: gapic_v1.method.wrap_method( - self.set_breakpoint, default_timeout=600.0, client_info=client_info, + self.set_breakpoint, + default_timeout=600.0, + client_info=client_info, ), self.get_breakpoint: gapic_v1.method.wrap_method( self.get_breakpoint, @@ -192,9 +194,9 @@ def _prep_wrapped_messages(self, client_info): def close(self): """Closes resources associated with the transport. - .. warning:: - Only call this method if the transport is NOT shared - with other clients - this may cause errors in other clients! + .. warning:: + Only call this method if the transport is NOT shared + with other clients - this may cause errors in other clients! """ raise NotImplementedError() diff --git a/google/cloud/debugger_v2/services/debugger2/transports/grpc.py b/google/cloud/debugger_v2/services/debugger2/transports/grpc.py index 9df8b3d..83bd57f 100644 --- a/google/cloud/debugger_v2/services/debugger2/transports/grpc.py +++ b/google/cloud/debugger_v2/services/debugger2/transports/grpc.py @@ -237,8 +237,7 @@ def create_channel( @property def grpc_channel(self) -> grpc.Channel: - """Return the channel designed to connect to this service. - """ + """Return the channel designed to connect to this service.""" return self._grpc_channel @property diff --git a/google/cloud/debugger_v2/types/controller.py b/google/cloud/debugger_v2/types/controller.py index 51df565..ebf452f 100644 --- a/google/cloud/debugger_v2/types/controller.py +++ b/google/cloud/debugger_v2/types/controller.py @@ -41,7 +41,11 @@ class RegisterDebuggeeRequest(proto.Message): ``agent_version`` of the debuggee must be set. """ - debuggee = proto.Field(proto.MESSAGE, number=1, message=data.Debuggee,) + debuggee = proto.Field( + proto.MESSAGE, + number=1, + message=data.Debuggee, + ) class RegisterDebuggeeResponse(proto.Message): @@ -57,7 +61,11 @@ class RegisterDebuggeeResponse(proto.Message): ``RegisterDebuggee`` until reenabled. """ - debuggee = proto.Field(proto.MESSAGE, number=1, message=data.Debuggee,) + debuggee = proto.Field( + proto.MESSAGE, + number=1, + message=data.Debuggee, + ) class ListActiveBreakpointsRequest(proto.Message): @@ -83,9 +91,18 @@ class ListActiveBreakpointsRequest(proto.Message): timeout has expired. """ - debuggee_id = proto.Field(proto.STRING, number=1,) - wait_token = proto.Field(proto.STRING, number=2,) - success_on_timeout = proto.Field(proto.BOOL, number=3,) + debuggee_id = proto.Field( + proto.STRING, + number=1, + ) + wait_token = proto.Field( + proto.STRING, + number=2, + ) + success_on_timeout = proto.Field( + proto.BOOL, + number=3, + ) class ListActiveBreakpointsResponse(proto.Message): @@ -106,9 +123,19 @@ class ListActiveBreakpointsResponse(proto.Message): should be ignored. """ - breakpoints = proto.RepeatedField(proto.MESSAGE, number=1, message=data.Breakpoint,) - next_wait_token = proto.Field(proto.STRING, number=2,) - wait_expired = proto.Field(proto.BOOL, number=3,) + breakpoints = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=data.Breakpoint, + ) + next_wait_token = proto.Field( + proto.STRING, + number=2, + ) + wait_expired = proto.Field( + proto.BOOL, + number=3, + ) class UpdateActiveBreakpointRequest(proto.Message): @@ -124,8 +151,15 @@ class UpdateActiveBreakpointRequest(proto.Message): specification fields in the update. """ - debuggee_id = proto.Field(proto.STRING, number=1,) - breakpoint_ = proto.Field(proto.MESSAGE, number=2, message=data.Breakpoint,) + debuggee_id = proto.Field( + proto.STRING, + number=1, + ) + breakpoint_ = proto.Field( + proto.MESSAGE, + number=2, + message=data.Breakpoint, + ) class UpdateActiveBreakpointResponse(proto.Message): diff --git a/google/cloud/debugger_v2/types/data.py b/google/cloud/debugger_v2/types/data.py index adf429b..2e9e7e2 100644 --- a/google/cloud/debugger_v2/types/data.py +++ b/google/cloud/debugger_v2/types/data.py @@ -52,8 +52,14 @@ class FormatMessage(proto.Message): message. """ - format_ = proto.Field(proto.STRING, number=1,) - parameters = proto.RepeatedField(proto.STRING, number=2,) + format_ = proto.Field( + proto.STRING, + number=1, + ) + parameters = proto.RepeatedField( + proto.STRING, + number=2, + ) class StatusMessage(proto.Message): @@ -83,9 +89,20 @@ class Reference(proto.Enum): VARIABLE_NAME = 5 VARIABLE_VALUE = 6 - is_error = proto.Field(proto.BOOL, number=1,) - refers_to = proto.Field(proto.ENUM, number=2, enum=Reference,) - description = proto.Field(proto.MESSAGE, number=3, message="FormatMessage",) + is_error = proto.Field( + proto.BOOL, + number=1, + ) + refers_to = proto.Field( + proto.ENUM, + number=2, + enum=Reference, + ) + description = proto.Field( + proto.MESSAGE, + number=3, + message="FormatMessage", + ) class SourceLocation(proto.Message): @@ -104,9 +121,18 @@ class SourceLocation(proto.Message): on specific columns ignore this field. """ - path = proto.Field(proto.STRING, number=1,) - line = proto.Field(proto.INT32, number=2,) - column = proto.Field(proto.INT32, number=3,) + path = proto.Field( + proto.STRING, + number=1, + ) + line = proto.Field( + proto.INT32, + number=2, + ) + column = proto.Field( + proto.INT32, + number=3, + ) class Variable(proto.Message): @@ -240,14 +266,33 @@ class Variable(proto.Message): - ``Null pointer dereference`` """ - name = proto.Field(proto.STRING, number=1,) - value = proto.Field(proto.STRING, number=2,) - type_ = proto.Field(proto.STRING, number=6,) - members = proto.RepeatedField(proto.MESSAGE, number=3, message="Variable",) + name = proto.Field( + proto.STRING, + number=1, + ) + value = proto.Field( + proto.STRING, + number=2, + ) + type_ = proto.Field( + proto.STRING, + number=6, + ) + members = proto.RepeatedField( + proto.MESSAGE, + number=3, + message="Variable", + ) var_table_index = proto.Field( - proto.MESSAGE, number=4, message=wrappers_pb2.Int32Value, + proto.MESSAGE, + number=4, + message=wrappers_pb2.Int32Value, + ) + status = proto.Field( + proto.MESSAGE, + number=5, + message="StatusMessage", ) - status = proto.Field(proto.MESSAGE, number=5, message="StatusMessage",) class StackFrame(proto.Message): @@ -268,10 +313,25 @@ class StackFrame(proto.Message): for all stack frames. """ - function = proto.Field(proto.STRING, number=1,) - location = proto.Field(proto.MESSAGE, number=2, message="SourceLocation",) - arguments = proto.RepeatedField(proto.MESSAGE, number=3, message="Variable",) - locals_ = proto.RepeatedField(proto.MESSAGE, number=4, message="Variable",) + function = proto.Field( + proto.STRING, + number=1, + ) + location = proto.Field( + proto.MESSAGE, + number=2, + message="SourceLocation", + ) + arguments = proto.RepeatedField( + proto.MESSAGE, + number=3, + message="Variable", + ) + locals_ = proto.RepeatedField( + proto.MESSAGE, + number=4, + message="Variable", + ) class Breakpoint(proto.Message): @@ -387,26 +447,80 @@ class LogLevel(proto.Enum): WARNING = 1 ERROR = 2 - id = proto.Field(proto.STRING, number=1,) - action = proto.Field(proto.ENUM, number=13, enum=Action,) - location = proto.Field(proto.MESSAGE, number=2, message="SourceLocation",) - condition = proto.Field(proto.STRING, number=3,) - expressions = proto.RepeatedField(proto.STRING, number=4,) - log_message_format = proto.Field(proto.STRING, number=14,) - log_level = proto.Field(proto.ENUM, number=15, enum=LogLevel,) - is_final_state = proto.Field(proto.BOOL, number=5,) + id = proto.Field( + proto.STRING, + number=1, + ) + action = proto.Field( + proto.ENUM, + number=13, + enum=Action, + ) + location = proto.Field( + proto.MESSAGE, + number=2, + message="SourceLocation", + ) + condition = proto.Field( + proto.STRING, + number=3, + ) + expressions = proto.RepeatedField( + proto.STRING, + number=4, + ) + log_message_format = proto.Field( + proto.STRING, + number=14, + ) + log_level = proto.Field( + proto.ENUM, + number=15, + enum=LogLevel, + ) + is_final_state = proto.Field( + proto.BOOL, + number=5, + ) create_time = proto.Field( - proto.MESSAGE, number=11, message=timestamp_pb2.Timestamp, + proto.MESSAGE, + number=11, + message=timestamp_pb2.Timestamp, + ) + final_time = proto.Field( + proto.MESSAGE, + number=12, + message=timestamp_pb2.Timestamp, + ) + user_email = proto.Field( + proto.STRING, + number=16, + ) + status = proto.Field( + proto.MESSAGE, + number=10, + message="StatusMessage", + ) + stack_frames = proto.RepeatedField( + proto.MESSAGE, + number=7, + message="StackFrame", ) - final_time = proto.Field(proto.MESSAGE, number=12, message=timestamp_pb2.Timestamp,) - user_email = proto.Field(proto.STRING, number=16,) - status = proto.Field(proto.MESSAGE, number=10, message="StatusMessage",) - stack_frames = proto.RepeatedField(proto.MESSAGE, number=7, message="StackFrame",) evaluated_expressions = proto.RepeatedField( - proto.MESSAGE, number=8, message="Variable", + proto.MESSAGE, + number=8, + message="Variable", + ) + variable_table = proto.RepeatedField( + proto.MESSAGE, + number=9, + message="Variable", + ) + labels = proto.MapField( + proto.STRING, + proto.STRING, + number=17, ) - variable_table = proto.RepeatedField(proto.MESSAGE, number=9, message="Variable",) - labels = proto.MapField(proto.STRING, proto.STRING, number=17,) class Debuggee(proto.Message): @@ -471,21 +585,54 @@ class Debuggee(proto.Message): user. """ - id = proto.Field(proto.STRING, number=1,) - project = proto.Field(proto.STRING, number=2,) - uniquifier = proto.Field(proto.STRING, number=3,) - description = proto.Field(proto.STRING, number=4,) - is_inactive = proto.Field(proto.BOOL, number=5,) - agent_version = proto.Field(proto.STRING, number=6,) - is_disabled = proto.Field(proto.BOOL, number=7,) - status = proto.Field(proto.MESSAGE, number=8, message="StatusMessage",) + id = proto.Field( + proto.STRING, + number=1, + ) + project = proto.Field( + proto.STRING, + number=2, + ) + uniquifier = proto.Field( + proto.STRING, + number=3, + ) + description = proto.Field( + proto.STRING, + number=4, + ) + is_inactive = proto.Field( + proto.BOOL, + number=5, + ) + agent_version = proto.Field( + proto.STRING, + number=6, + ) + is_disabled = proto.Field( + proto.BOOL, + number=7, + ) + status = proto.Field( + proto.MESSAGE, + number=8, + message="StatusMessage", + ) source_contexts = proto.RepeatedField( - proto.MESSAGE, number=9, message=source_context_pb2.SourceContext, + proto.MESSAGE, + number=9, + message=source_context_pb2.SourceContext, ) ext_source_contexts = proto.RepeatedField( - proto.MESSAGE, number=13, message=source_context_pb2.ExtendedSourceContext, + proto.MESSAGE, + number=13, + message=source_context_pb2.ExtendedSourceContext, + ) + labels = proto.MapField( + proto.STRING, + proto.STRING, + number=11, ) - labels = proto.MapField(proto.STRING, proto.STRING, number=11,) __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/google/cloud/debugger_v2/types/debugger.py b/google/cloud/debugger_v2/types/debugger.py index 0c34f2b..878c1ed 100644 --- a/google/cloud/debugger_v2/types/debugger.py +++ b/google/cloud/debugger_v2/types/debugger.py @@ -49,9 +49,19 @@ class SetBreakpointRequest(proto.Message): ``domain/type/version`` (e.g., ``google.com/intellij/v1``). """ - debuggee_id = proto.Field(proto.STRING, number=1,) - breakpoint_ = proto.Field(proto.MESSAGE, number=2, message=data.Breakpoint,) - client_version = proto.Field(proto.STRING, number=4,) + debuggee_id = proto.Field( + proto.STRING, + number=1, + ) + breakpoint_ = proto.Field( + proto.MESSAGE, + number=2, + message=data.Breakpoint, + ) + client_version = proto.Field( + proto.STRING, + number=4, + ) class SetBreakpointResponse(proto.Message): @@ -63,7 +73,11 @@ class SetBreakpointResponse(proto.Message): set (in addition to the echoed fileds). """ - breakpoint_ = proto.Field(proto.MESSAGE, number=1, message=data.Breakpoint,) + breakpoint_ = proto.Field( + proto.MESSAGE, + number=1, + message=data.Breakpoint, + ) class GetBreakpointRequest(proto.Message): @@ -80,9 +94,18 @@ class GetBreakpointRequest(proto.Message): ``domain/type/version`` (e.g., ``google.com/intellij/v1``). """ - debuggee_id = proto.Field(proto.STRING, number=1,) - breakpoint_id = proto.Field(proto.STRING, number=2,) - client_version = proto.Field(proto.STRING, number=4,) + debuggee_id = proto.Field( + proto.STRING, + number=1, + ) + breakpoint_id = proto.Field( + proto.STRING, + number=2, + ) + client_version = proto.Field( + proto.STRING, + number=4, + ) class GetBreakpointResponse(proto.Message): @@ -94,7 +117,11 @@ class GetBreakpointResponse(proto.Message): ``location`` are guaranteed to be set. """ - breakpoint_ = proto.Field(proto.MESSAGE, number=1, message=data.Breakpoint,) + breakpoint_ = proto.Field( + proto.MESSAGE, + number=1, + message=data.Breakpoint, + ) class DeleteBreakpointRequest(proto.Message): @@ -111,9 +138,18 @@ class DeleteBreakpointRequest(proto.Message): ``domain/type/version`` (e.g., ``google.com/intellij/v1``). """ - debuggee_id = proto.Field(proto.STRING, number=1,) - breakpoint_id = proto.Field(proto.STRING, number=2,) - client_version = proto.Field(proto.STRING, number=3,) + debuggee_id = proto.Field( + proto.STRING, + number=1, + ) + breakpoint_id = proto.Field( + proto.STRING, + number=2, + ) + client_version = proto.Field( + proto.STRING, + number=3, + ) class ListBreakpointsRequest(proto.Message): @@ -160,15 +196,41 @@ class BreakpointActionValue(proto.Message): will pass the filter. """ - value = proto.Field(proto.ENUM, number=1, enum=data.Breakpoint.Action,) - - debuggee_id = proto.Field(proto.STRING, number=1,) - include_all_users = proto.Field(proto.BOOL, number=2,) - include_inactive = proto.Field(proto.BOOL, number=3,) - action = proto.Field(proto.MESSAGE, number=4, message=BreakpointActionValue,) - strip_results = proto.Field(proto.BOOL, number=5,) - wait_token = proto.Field(proto.STRING, number=6,) - client_version = proto.Field(proto.STRING, number=8,) + value = proto.Field( + proto.ENUM, + number=1, + enum=data.Breakpoint.Action, + ) + + debuggee_id = proto.Field( + proto.STRING, + number=1, + ) + include_all_users = proto.Field( + proto.BOOL, + number=2, + ) + include_inactive = proto.Field( + proto.BOOL, + number=3, + ) + action = proto.Field( + proto.MESSAGE, + number=4, + message=BreakpointActionValue, + ) + strip_results = proto.Field( + proto.BOOL, + number=5, + ) + wait_token = proto.Field( + proto.STRING, + number=6, + ) + client_version = proto.Field( + proto.STRING, + number=8, + ) class ListBreakpointsResponse(proto.Message): @@ -187,8 +249,15 @@ class ListBreakpointsResponse(proto.Message): of breakpoints has changes. """ - breakpoints = proto.RepeatedField(proto.MESSAGE, number=1, message=data.Breakpoint,) - next_wait_token = proto.Field(proto.STRING, number=2,) + breakpoints = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=data.Breakpoint, + ) + next_wait_token = proto.Field( + proto.STRING, + number=2, + ) class ListDebuggeesRequest(proto.Message): @@ -207,9 +276,18 @@ class ListDebuggeesRequest(proto.Message): ``domain/type/version`` (e.g., ``google.com/intellij/v1``). """ - project = proto.Field(proto.STRING, number=2,) - include_inactive = proto.Field(proto.BOOL, number=3,) - client_version = proto.Field(proto.STRING, number=4,) + project = proto.Field( + proto.STRING, + number=2, + ) + include_inactive = proto.Field( + proto.BOOL, + number=3, + ) + client_version = proto.Field( + proto.STRING, + number=4, + ) class ListDebuggeesResponse(proto.Message): @@ -223,7 +301,11 @@ class ListDebuggeesResponse(proto.Message): provided by agents and can be displayed to users. """ - debuggees = proto.RepeatedField(proto.MESSAGE, number=1, message=data.Debuggee,) + debuggees = proto.RepeatedField( + proto.MESSAGE, + number=1, + message=data.Debuggee, + ) __all__ = tuple(sorted(__protobuf__.manifest)) diff --git a/noxfile.py b/noxfile.py index 2a2001c..3addb4e 100644 --- a/noxfile.py +++ b/noxfile.py @@ -24,7 +24,7 @@ import nox -BLACK_VERSION = "black==19.10b0" +BLACK_VERSION = "black==22.3.0" BLACK_PATHS = ["docs", "google", "tests", "noxfile.py", "setup.py"] DEFAULT_PYTHON_VERSION = "3.8" @@ -57,7 +57,9 @@ def lint(session): """ session.install("flake8", BLACK_VERSION) session.run( - "black", "--check", *BLACK_PATHS, + "black", + "--check", + *BLACK_PATHS, ) session.run("flake8", "google", "tests") @@ -67,7 +69,8 @@ def blacken(session): """Run black. Format code to uniform standard.""" session.install(BLACK_VERSION) session.run( - "black", *BLACK_PATHS, + "black", + *BLACK_PATHS, ) diff --git a/tests/unit/gapic/debugger_v2/test_controller2.py b/tests/unit/gapic/debugger_v2/test_controller2.py index e589508..b4faf5b 100644 --- a/tests/unit/gapic/debugger_v2/test_controller2.py +++ b/tests/unit/gapic/debugger_v2/test_controller2.py @@ -84,7 +84,13 @@ def test__get_default_mtls_endpoint(): assert Controller2Client._get_default_mtls_endpoint(non_googleapi) == non_googleapi -@pytest.mark.parametrize("client_class", [Controller2Client, Controller2AsyncClient,]) +@pytest.mark.parametrize( + "client_class", + [ + Controller2Client, + Controller2AsyncClient, + ], +) def test_controller2_client_from_service_account_info(client_class): creds = ga_credentials.AnonymousCredentials() with mock.patch.object( @@ -124,7 +130,13 @@ def test_controller2_client_service_account_always_use_jwt( use_jwt.assert_not_called() -@pytest.mark.parametrize("client_class", [Controller2Client, Controller2AsyncClient,]) +@pytest.mark.parametrize( + "client_class", + [ + Controller2Client, + Controller2AsyncClient, + ], +) def test_controller2_client_from_service_account_file(client_class): creds = ga_credentials.AnonymousCredentials() with mock.patch.object( @@ -479,7 +491,9 @@ def test_controller2_client_client_options_scopes( client_class, transport_class, transport_name ): # Check the case scopes are provided. - options = client_options.ClientOptions(scopes=["1", "2"],) + options = client_options.ClientOptions( + scopes=["1", "2"], + ) with mock.patch.object(transport_class, "__init__") as patched: patched.return_value = None client = client_class(client_options=options, transport=transport_name) @@ -610,10 +624,17 @@ def test_controller2_client_create_channel_credentials_file( ) -@pytest.mark.parametrize("request_type", [controller.RegisterDebuggeeRequest, dict,]) +@pytest.mark.parametrize( + "request_type", + [ + controller.RegisterDebuggeeRequest, + dict, + ], +) def test_register_debuggee(request_type, transport: str = "grpc"): client = Controller2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -641,7 +662,8 @@ def test_register_debuggee_empty_call(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. client = Controller2Client( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -659,7 +681,8 @@ async def test_register_debuggee_async( transport: str = "grpc_asyncio", request_type=controller.RegisterDebuggeeRequest ): client = Controller2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -691,7 +714,9 @@ async def test_register_debuggee_async_from_dict(): def test_register_debuggee_flattened(): - client = Controller2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( @@ -701,7 +726,9 @@ def test_register_debuggee_flattened(): call.return_value = controller.RegisterDebuggeeResponse() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.register_debuggee(debuggee=data.Debuggee(id="id_value"),) + client.register_debuggee( + debuggee=data.Debuggee(id="id_value"), + ) # Establish that the underlying call was made with the expected # request object values. @@ -713,19 +740,24 @@ def test_register_debuggee_flattened(): def test_register_debuggee_flattened_error(): - client = Controller2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): client.register_debuggee( - controller.RegisterDebuggeeRequest(), debuggee=data.Debuggee(id="id_value"), + controller.RegisterDebuggeeRequest(), + debuggee=data.Debuggee(id="id_value"), ) @pytest.mark.asyncio async def test_register_debuggee_flattened_async(): - client = Controller2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( @@ -754,22 +786,30 @@ async def test_register_debuggee_flattened_async(): @pytest.mark.asyncio async def test_register_debuggee_flattened_error_async(): - client = Controller2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): await client.register_debuggee( - controller.RegisterDebuggeeRequest(), debuggee=data.Debuggee(id="id_value"), + controller.RegisterDebuggeeRequest(), + debuggee=data.Debuggee(id="id_value"), ) @pytest.mark.parametrize( - "request_type", [controller.ListActiveBreakpointsRequest, dict,] + "request_type", + [ + controller.ListActiveBreakpointsRequest, + dict, + ], ) def test_list_active_breakpoints(request_type, transport: str = "grpc"): client = Controller2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -782,7 +822,8 @@ def test_list_active_breakpoints(request_type, transport: str = "grpc"): ) as call: # Designate an appropriate return value for the call. call.return_value = controller.ListActiveBreakpointsResponse( - next_wait_token="next_wait_token_value", wait_expired=True, + next_wait_token="next_wait_token_value", + wait_expired=True, ) response = client.list_active_breakpoints(request) @@ -801,7 +842,8 @@ def test_list_active_breakpoints_empty_call(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. client = Controller2Client( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -820,7 +862,8 @@ async def test_list_active_breakpoints_async( request_type=controller.ListActiveBreakpointsRequest, ): client = Controller2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -834,7 +877,8 @@ async def test_list_active_breakpoints_async( # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( controller.ListActiveBreakpointsResponse( - next_wait_token="next_wait_token_value", wait_expired=True, + next_wait_token="next_wait_token_value", + wait_expired=True, ) ) response = await client.list_active_breakpoints(request) @@ -856,7 +900,9 @@ async def test_list_active_breakpoints_async_from_dict(): def test_list_active_breakpoints_flattened(): - client = Controller2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( @@ -866,7 +912,9 @@ def test_list_active_breakpoints_flattened(): call.return_value = controller.ListActiveBreakpointsResponse() # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. - client.list_active_breakpoints(debuggee_id="debuggee_id_value",) + client.list_active_breakpoints( + debuggee_id="debuggee_id_value", + ) # Establish that the underlying call was made with the expected # request object values. @@ -878,19 +926,24 @@ def test_list_active_breakpoints_flattened(): def test_list_active_breakpoints_flattened_error(): - client = Controller2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): client.list_active_breakpoints( - controller.ListActiveBreakpointsRequest(), debuggee_id="debuggee_id_value", + controller.ListActiveBreakpointsRequest(), + debuggee_id="debuggee_id_value", ) @pytest.mark.asyncio async def test_list_active_breakpoints_flattened_async(): - client = Controller2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( @@ -919,22 +972,30 @@ async def test_list_active_breakpoints_flattened_async(): @pytest.mark.asyncio async def test_list_active_breakpoints_flattened_error_async(): - client = Controller2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. with pytest.raises(ValueError): await client.list_active_breakpoints( - controller.ListActiveBreakpointsRequest(), debuggee_id="debuggee_id_value", + controller.ListActiveBreakpointsRequest(), + debuggee_id="debuggee_id_value", ) @pytest.mark.parametrize( - "request_type", [controller.UpdateActiveBreakpointRequest, dict,] + "request_type", + [ + controller.UpdateActiveBreakpointRequest, + dict, + ], ) def test_update_active_breakpoint(request_type, transport: str = "grpc"): client = Controller2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -962,7 +1023,8 @@ def test_update_active_breakpoint_empty_call(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. client = Controller2Client( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -981,7 +1043,8 @@ async def test_update_active_breakpoint_async( request_type=controller.UpdateActiveBreakpointRequest, ): client = Controller2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -1013,7 +1076,9 @@ async def test_update_active_breakpoint_async_from_dict(): def test_update_active_breakpoint_flattened(): - client = Controller2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( @@ -1024,7 +1089,8 @@ def test_update_active_breakpoint_flattened(): # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. client.update_active_breakpoint( - debuggee_id="debuggee_id_value", breakpoint_=data.Breakpoint(id="id_value"), + debuggee_id="debuggee_id_value", + breakpoint_=data.Breakpoint(id="id_value"), ) # Establish that the underlying call was made with the expected @@ -1040,7 +1106,9 @@ def test_update_active_breakpoint_flattened(): def test_update_active_breakpoint_flattened_error(): - client = Controller2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -1054,7 +1122,9 @@ def test_update_active_breakpoint_flattened_error(): @pytest.mark.asyncio async def test_update_active_breakpoint_flattened_async(): - client = Controller2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( @@ -1069,7 +1139,8 @@ async def test_update_active_breakpoint_flattened_async(): # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. response = await client.update_active_breakpoint( - debuggee_id="debuggee_id_value", breakpoint_=data.Breakpoint(id="id_value"), + debuggee_id="debuggee_id_value", + breakpoint_=data.Breakpoint(id="id_value"), ) # Establish that the underlying call was made with the expected @@ -1086,7 +1157,9 @@ async def test_update_active_breakpoint_flattened_async(): @pytest.mark.asyncio async def test_update_active_breakpoint_flattened_error_async(): - client = Controller2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -1105,7 +1178,8 @@ def test_credentials_transport_error(): ) with pytest.raises(ValueError): client = Controller2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # It is an error to provide a credentials file and a transport instance. @@ -1125,7 +1199,10 @@ def test_credentials_transport_error(): options = client_options.ClientOptions() options.api_key = "api_key" with pytest.raises(ValueError): - client = Controller2Client(client_options=options, transport=transport,) + client = Controller2Client( + client_options=options, + transport=transport, + ) # It is an error to provide an api_key and a credential. options = mock.Mock() @@ -1141,7 +1218,8 @@ def test_credentials_transport_error(): ) with pytest.raises(ValueError): client = Controller2Client( - client_options={"scopes": ["1", "2"]}, transport=transport, + client_options={"scopes": ["1", "2"]}, + transport=transport, ) @@ -1171,7 +1249,10 @@ def test_transport_get_channel(): @pytest.mark.parametrize( "transport_class", - [transports.Controller2GrpcTransport, transports.Controller2GrpcAsyncIOTransport,], + [ + transports.Controller2GrpcTransport, + transports.Controller2GrpcAsyncIOTransport, + ], ) def test_transport_adc(transport_class): # Test default credentials are used if not provided. @@ -1183,8 +1264,13 @@ def test_transport_adc(transport_class): def test_transport_grpc_default(): # A client should use the gRPC transport by default. - client = Controller2Client(credentials=ga_credentials.AnonymousCredentials(),) - assert isinstance(client.transport, transports.Controller2GrpcTransport,) + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + assert isinstance( + client.transport, + transports.Controller2GrpcTransport, + ) def test_controller2_base_transport_error(): @@ -1231,7 +1317,8 @@ def test_controller2_base_transport_with_credentials_file(): Transport.return_value = None load_creds.return_value = (ga_credentials.AnonymousCredentials(), None) transport = transports.Controller2Transport( - credentials_file="credentials.json", quota_project_id="octopus", + credentials_file="credentials.json", + quota_project_id="octopus", ) load_creds.assert_called_once_with( "credentials.json", @@ -1272,7 +1359,10 @@ def test_controller2_auth_adc(): @pytest.mark.parametrize( "transport_class", - [transports.Controller2GrpcTransport, transports.Controller2GrpcAsyncIOTransport,], + [ + transports.Controller2GrpcTransport, + transports.Controller2GrpcAsyncIOTransport, + ], ) def test_controller2_transport_auth_adc(transport_class): # If credentials and host are not provided, the transport class should use @@ -1395,7 +1485,8 @@ def test_controller2_grpc_transport_channel(): # Check that channel is used if provided. transport = transports.Controller2GrpcTransport( - host="squid.clam.whelk", channel=channel, + host="squid.clam.whelk", + channel=channel, ) assert transport.grpc_channel == channel assert transport._host == "squid.clam.whelk:443" @@ -1407,7 +1498,8 @@ def test_controller2_grpc_asyncio_transport_channel(): # Check that channel is used if provided. transport = transports.Controller2GrpcAsyncIOTransport( - host="squid.clam.whelk", channel=channel, + host="squid.clam.whelk", + channel=channel, ) assert transport.grpc_channel == channel assert transport._host == "squid.clam.whelk:443" @@ -1528,7 +1620,9 @@ def test_parse_common_billing_account_path(): def test_common_folder_path(): folder = "whelk" - expected = "folders/{folder}".format(folder=folder,) + expected = "folders/{folder}".format( + folder=folder, + ) actual = Controller2Client.common_folder_path(folder) assert expected == actual @@ -1546,7 +1640,9 @@ def test_parse_common_folder_path(): def test_common_organization_path(): organization = "oyster" - expected = "organizations/{organization}".format(organization=organization,) + expected = "organizations/{organization}".format( + organization=organization, + ) actual = Controller2Client.common_organization_path(organization) assert expected == actual @@ -1564,7 +1660,9 @@ def test_parse_common_organization_path(): def test_common_project_path(): project = "cuttlefish" - expected = "projects/{project}".format(project=project,) + expected = "projects/{project}".format( + project=project, + ) actual = Controller2Client.common_project_path(project) assert expected == actual @@ -1584,7 +1682,8 @@ def test_common_location_path(): project = "winkle" location = "nautilus" expected = "projects/{project}/locations/{location}".format( - project=project, location=location, + project=project, + location=location, ) actual = Controller2Client.common_location_path(project, location) assert expected == actual @@ -1609,7 +1708,8 @@ def test_client_with_default_client_info(): transports.Controller2Transport, "_prep_wrapped_messages" ) as prep: client = Controller2Client( - credentials=ga_credentials.AnonymousCredentials(), client_info=client_info, + credentials=ga_credentials.AnonymousCredentials(), + client_info=client_info, ) prep.assert_called_once_with(client_info) @@ -1618,7 +1718,8 @@ def test_client_with_default_client_info(): ) as prep: transport_class = Controller2Client.get_transport_class() transport = transport_class( - credentials=ga_credentials.AnonymousCredentials(), client_info=client_info, + credentials=ga_credentials.AnonymousCredentials(), + client_info=client_info, ) prep.assert_called_once_with(client_info) @@ -1626,7 +1727,8 @@ def test_client_with_default_client_info(): @pytest.mark.asyncio async def test_transport_close_async(): client = Controller2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc_asyncio", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc_asyncio", ) with mock.patch.object( type(getattr(client.transport, "grpc_channel")), "close" diff --git a/tests/unit/gapic/debugger_v2/test_debugger2.py b/tests/unit/gapic/debugger_v2/test_debugger2.py index 3f4810c..5db1005 100644 --- a/tests/unit/gapic/debugger_v2/test_debugger2.py +++ b/tests/unit/gapic/debugger_v2/test_debugger2.py @@ -81,7 +81,13 @@ def test__get_default_mtls_endpoint(): assert Debugger2Client._get_default_mtls_endpoint(non_googleapi) == non_googleapi -@pytest.mark.parametrize("client_class", [Debugger2Client, Debugger2AsyncClient,]) +@pytest.mark.parametrize( + "client_class", + [ + Debugger2Client, + Debugger2AsyncClient, + ], +) def test_debugger2_client_from_service_account_info(client_class): creds = ga_credentials.AnonymousCredentials() with mock.patch.object( @@ -121,7 +127,13 @@ def test_debugger2_client_service_account_always_use_jwt( use_jwt.assert_not_called() -@pytest.mark.parametrize("client_class", [Debugger2Client, Debugger2AsyncClient,]) +@pytest.mark.parametrize( + "client_class", + [ + Debugger2Client, + Debugger2AsyncClient, + ], +) def test_debugger2_client_from_service_account_file(client_class): creds = ga_credentials.AnonymousCredentials() with mock.patch.object( @@ -474,7 +486,9 @@ def test_debugger2_client_client_options_scopes( client_class, transport_class, transport_name ): # Check the case scopes are provided. - options = client_options.ClientOptions(scopes=["1", "2"],) + options = client_options.ClientOptions( + scopes=["1", "2"], + ) with mock.patch.object(transport_class, "__init__") as patched: patched.return_value = None client = client_class(client_options=options, transport=transport_name) @@ -605,10 +619,17 @@ def test_debugger2_client_create_channel_credentials_file( ) -@pytest.mark.parametrize("request_type", [debugger.SetBreakpointRequest, dict,]) +@pytest.mark.parametrize( + "request_type", + [ + debugger.SetBreakpointRequest, + dict, + ], +) def test_set_breakpoint(request_type, transport: str = "grpc"): client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -634,7 +655,8 @@ def test_set_breakpoint_empty_call(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -650,7 +672,8 @@ async def test_set_breakpoint_async( transport: str = "grpc_asyncio", request_type=debugger.SetBreakpointRequest ): client = Debugger2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -680,7 +703,9 @@ async def test_set_breakpoint_async_from_dict(): def test_set_breakpoint_flattened(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object(type(client.transport.set_breakpoint), "__call__") as call: @@ -710,7 +735,9 @@ def test_set_breakpoint_flattened(): def test_set_breakpoint_flattened_error(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -725,7 +752,9 @@ def test_set_breakpoint_flattened_error(): @pytest.mark.asyncio async def test_set_breakpoint_flattened_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object(type(client.transport.set_breakpoint), "__call__") as call: @@ -760,7 +789,9 @@ async def test_set_breakpoint_flattened_async(): @pytest.mark.asyncio async def test_set_breakpoint_flattened_error_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -773,10 +804,17 @@ async def test_set_breakpoint_flattened_error_async(): ) -@pytest.mark.parametrize("request_type", [debugger.GetBreakpointRequest, dict,]) +@pytest.mark.parametrize( + "request_type", + [ + debugger.GetBreakpointRequest, + dict, + ], +) def test_get_breakpoint(request_type, transport: str = "grpc"): client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -802,7 +840,8 @@ def test_get_breakpoint_empty_call(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -818,7 +857,8 @@ async def test_get_breakpoint_async( transport: str = "grpc_asyncio", request_type=debugger.GetBreakpointRequest ): client = Debugger2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -848,7 +888,9 @@ async def test_get_breakpoint_async_from_dict(): def test_get_breakpoint_flattened(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object(type(client.transport.get_breakpoint), "__call__") as call: @@ -878,7 +920,9 @@ def test_get_breakpoint_flattened(): def test_get_breakpoint_flattened_error(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -893,7 +937,9 @@ def test_get_breakpoint_flattened_error(): @pytest.mark.asyncio async def test_get_breakpoint_flattened_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object(type(client.transport.get_breakpoint), "__call__") as call: @@ -928,7 +974,9 @@ async def test_get_breakpoint_flattened_async(): @pytest.mark.asyncio async def test_get_breakpoint_flattened_error_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -941,10 +989,17 @@ async def test_get_breakpoint_flattened_error_async(): ) -@pytest.mark.parametrize("request_type", [debugger.DeleteBreakpointRequest, dict,]) +@pytest.mark.parametrize( + "request_type", + [ + debugger.DeleteBreakpointRequest, + dict, + ], +) def test_delete_breakpoint(request_type, transport: str = "grpc"): client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -972,7 +1027,8 @@ def test_delete_breakpoint_empty_call(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -990,7 +1046,8 @@ async def test_delete_breakpoint_async( transport: str = "grpc_asyncio", request_type=debugger.DeleteBreakpointRequest ): client = Debugger2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -1020,7 +1077,9 @@ async def test_delete_breakpoint_async_from_dict(): def test_delete_breakpoint_flattened(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( @@ -1052,7 +1111,9 @@ def test_delete_breakpoint_flattened(): def test_delete_breakpoint_flattened_error(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -1067,7 +1128,9 @@ def test_delete_breakpoint_flattened_error(): @pytest.mark.asyncio async def test_delete_breakpoint_flattened_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object( @@ -1102,7 +1165,9 @@ async def test_delete_breakpoint_flattened_async(): @pytest.mark.asyncio async def test_delete_breakpoint_flattened_error_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -1115,10 +1180,17 @@ async def test_delete_breakpoint_flattened_error_async(): ) -@pytest.mark.parametrize("request_type", [debugger.ListBreakpointsRequest, dict,]) +@pytest.mark.parametrize( + "request_type", + [ + debugger.ListBreakpointsRequest, + dict, + ], +) def test_list_breakpoints(request_type, transport: str = "grpc"): client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -1147,7 +1219,8 @@ def test_list_breakpoints_empty_call(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -1163,7 +1236,8 @@ async def test_list_breakpoints_async( transport: str = "grpc_asyncio", request_type=debugger.ListBreakpointsRequest ): client = Debugger2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -1174,7 +1248,9 @@ async def test_list_breakpoints_async( with mock.patch.object(type(client.transport.list_breakpoints), "__call__") as call: # Designate an appropriate return value for the call. call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( - debugger.ListBreakpointsResponse(next_wait_token="next_wait_token_value",) + debugger.ListBreakpointsResponse( + next_wait_token="next_wait_token_value", + ) ) response = await client.list_breakpoints(request) @@ -1194,7 +1270,9 @@ async def test_list_breakpoints_async_from_dict(): def test_list_breakpoints_flattened(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object(type(client.transport.list_breakpoints), "__call__") as call: @@ -1203,7 +1281,8 @@ def test_list_breakpoints_flattened(): # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. client.list_breakpoints( - debuggee_id="debuggee_id_value", client_version="client_version_value", + debuggee_id="debuggee_id_value", + client_version="client_version_value", ) # Establish that the underlying call was made with the expected @@ -1219,7 +1298,9 @@ def test_list_breakpoints_flattened(): def test_list_breakpoints_flattened_error(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -1233,7 +1314,9 @@ def test_list_breakpoints_flattened_error(): @pytest.mark.asyncio async def test_list_breakpoints_flattened_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object(type(client.transport.list_breakpoints), "__call__") as call: @@ -1246,7 +1329,8 @@ async def test_list_breakpoints_flattened_async(): # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. response = await client.list_breakpoints( - debuggee_id="debuggee_id_value", client_version="client_version_value", + debuggee_id="debuggee_id_value", + client_version="client_version_value", ) # Establish that the underlying call was made with the expected @@ -1263,7 +1347,9 @@ async def test_list_breakpoints_flattened_async(): @pytest.mark.asyncio async def test_list_breakpoints_flattened_error_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -1275,10 +1361,17 @@ async def test_list_breakpoints_flattened_error_async(): ) -@pytest.mark.parametrize("request_type", [debugger.ListDebuggeesRequest, dict,]) +@pytest.mark.parametrize( + "request_type", + [ + debugger.ListDebuggeesRequest, + dict, + ], +) def test_list_debuggees(request_type, transport: str = "grpc"): client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -1304,7 +1397,8 @@ def test_list_debuggees_empty_call(): # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", ) # Mock the actual call within the gRPC stub, and fake the request. @@ -1320,7 +1414,8 @@ async def test_list_debuggees_async( transport: str = "grpc_asyncio", request_type=debugger.ListDebuggeesRequest ): client = Debugger2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # Everything is optional in proto3 as far as the runtime is concerned, @@ -1350,7 +1445,9 @@ async def test_list_debuggees_async_from_dict(): def test_list_debuggees_flattened(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object(type(client.transport.list_debuggees), "__call__") as call: @@ -1359,7 +1456,8 @@ def test_list_debuggees_flattened(): # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. client.list_debuggees( - project="project_value", client_version="client_version_value", + project="project_value", + client_version="client_version_value", ) # Establish that the underlying call was made with the expected @@ -1375,7 +1473,9 @@ def test_list_debuggees_flattened(): def test_list_debuggees_flattened_error(): - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -1389,7 +1489,9 @@ def test_list_debuggees_flattened_error(): @pytest.mark.asyncio async def test_list_debuggees_flattened_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Mock the actual call within the gRPC stub, and fake the request. with mock.patch.object(type(client.transport.list_debuggees), "__call__") as call: @@ -1402,7 +1504,8 @@ async def test_list_debuggees_flattened_async(): # Call the method with a truthy value for each flattened field, # using the keyword arguments to the method. response = await client.list_debuggees( - project="project_value", client_version="client_version_value", + project="project_value", + client_version="client_version_value", ) # Establish that the underlying call was made with the expected @@ -1419,7 +1522,9 @@ async def test_list_debuggees_flattened_async(): @pytest.mark.asyncio async def test_list_debuggees_flattened_error_async(): - client = Debugger2AsyncClient(credentials=ga_credentials.AnonymousCredentials(),) + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) # Attempting to call a method with both a request object and flattened # fields is an error. @@ -1438,7 +1543,8 @@ def test_credentials_transport_error(): ) with pytest.raises(ValueError): client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), transport=transport, + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, ) # It is an error to provide a credentials file and a transport instance. @@ -1458,7 +1564,10 @@ def test_credentials_transport_error(): options = client_options.ClientOptions() options.api_key = "api_key" with pytest.raises(ValueError): - client = Debugger2Client(client_options=options, transport=transport,) + client = Debugger2Client( + client_options=options, + transport=transport, + ) # It is an error to provide an api_key and a credential. options = mock.Mock() @@ -1474,7 +1583,8 @@ def test_credentials_transport_error(): ) with pytest.raises(ValueError): client = Debugger2Client( - client_options={"scopes": ["1", "2"]}, transport=transport, + client_options={"scopes": ["1", "2"]}, + transport=transport, ) @@ -1504,7 +1614,10 @@ def test_transport_get_channel(): @pytest.mark.parametrize( "transport_class", - [transports.Debugger2GrpcTransport, transports.Debugger2GrpcAsyncIOTransport,], + [ + transports.Debugger2GrpcTransport, + transports.Debugger2GrpcAsyncIOTransport, + ], ) def test_transport_adc(transport_class): # Test default credentials are used if not provided. @@ -1516,8 +1629,13 @@ def test_transport_adc(transport_class): def test_transport_grpc_default(): # A client should use the gRPC transport by default. - client = Debugger2Client(credentials=ga_credentials.AnonymousCredentials(),) - assert isinstance(client.transport, transports.Debugger2GrpcTransport,) + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + assert isinstance( + client.transport, + transports.Debugger2GrpcTransport, + ) def test_debugger2_base_transport_error(): @@ -1566,7 +1684,8 @@ def test_debugger2_base_transport_with_credentials_file(): Transport.return_value = None load_creds.return_value = (ga_credentials.AnonymousCredentials(), None) transport = transports.Debugger2Transport( - credentials_file="credentials.json", quota_project_id="octopus", + credentials_file="credentials.json", + quota_project_id="octopus", ) load_creds.assert_called_once_with( "credentials.json", @@ -1607,7 +1726,10 @@ def test_debugger2_auth_adc(): @pytest.mark.parametrize( "transport_class", - [transports.Debugger2GrpcTransport, transports.Debugger2GrpcAsyncIOTransport,], + [ + transports.Debugger2GrpcTransport, + transports.Debugger2GrpcAsyncIOTransport, + ], ) def test_debugger2_transport_auth_adc(transport_class): # If credentials and host are not provided, the transport class should use @@ -1730,7 +1852,8 @@ def test_debugger2_grpc_transport_channel(): # Check that channel is used if provided. transport = transports.Debugger2GrpcTransport( - host="squid.clam.whelk", channel=channel, + host="squid.clam.whelk", + channel=channel, ) assert transport.grpc_channel == channel assert transport._host == "squid.clam.whelk:443" @@ -1742,7 +1865,8 @@ def test_debugger2_grpc_asyncio_transport_channel(): # Check that channel is used if provided. transport = transports.Debugger2GrpcAsyncIOTransport( - host="squid.clam.whelk", channel=channel, + host="squid.clam.whelk", + channel=channel, ) assert transport.grpc_channel == channel assert transport._host == "squid.clam.whelk:443" @@ -1863,7 +1987,9 @@ def test_parse_common_billing_account_path(): def test_common_folder_path(): folder = "whelk" - expected = "folders/{folder}".format(folder=folder,) + expected = "folders/{folder}".format( + folder=folder, + ) actual = Debugger2Client.common_folder_path(folder) assert expected == actual @@ -1881,7 +2007,9 @@ def test_parse_common_folder_path(): def test_common_organization_path(): organization = "oyster" - expected = "organizations/{organization}".format(organization=organization,) + expected = "organizations/{organization}".format( + organization=organization, + ) actual = Debugger2Client.common_organization_path(organization) assert expected == actual @@ -1899,7 +2027,9 @@ def test_parse_common_organization_path(): def test_common_project_path(): project = "cuttlefish" - expected = "projects/{project}".format(project=project,) + expected = "projects/{project}".format( + project=project, + ) actual = Debugger2Client.common_project_path(project) assert expected == actual @@ -1919,7 +2049,8 @@ def test_common_location_path(): project = "winkle" location = "nautilus" expected = "projects/{project}/locations/{location}".format( - project=project, location=location, + project=project, + location=location, ) actual = Debugger2Client.common_location_path(project, location) assert expected == actual @@ -1944,7 +2075,8 @@ def test_client_with_default_client_info(): transports.Debugger2Transport, "_prep_wrapped_messages" ) as prep: client = Debugger2Client( - credentials=ga_credentials.AnonymousCredentials(), client_info=client_info, + credentials=ga_credentials.AnonymousCredentials(), + client_info=client_info, ) prep.assert_called_once_with(client_info) @@ -1953,7 +2085,8 @@ def test_client_with_default_client_info(): ) as prep: transport_class = Debugger2Client.get_transport_class() transport = transport_class( - credentials=ga_credentials.AnonymousCredentials(), client_info=client_info, + credentials=ga_credentials.AnonymousCredentials(), + client_info=client_info, ) prep.assert_called_once_with(client_info) @@ -1961,7 +2094,8 @@ def test_client_with_default_client_info(): @pytest.mark.asyncio async def test_transport_close_async(): client = Debugger2AsyncClient( - credentials=ga_credentials.AnonymousCredentials(), transport="grpc_asyncio", + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc_asyncio", ) with mock.patch.object( type(getattr(client.transport, "grpc_channel")), "close" From 8304deb38e0da8e932c8e9ec6fd249360d4937aa Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Wed, 30 Mar 2022 16:56:16 +0000 Subject: [PATCH 02/19] chore(python): add E231 to .flake8 ignore list (#82) Source-Link: https://github.com/googleapis/synthtool/commit/7ff4aad2ec5af0380e8bd6da1fa06eaadf24ec81 Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:462782b0b492346b2d9099aaff52206dd30bc8e031ea97082e6facecc2373244 --- .flake8 | 2 +- .github/.OwlBot.lock.yaml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/.flake8 b/.flake8 index 29227d4..2e43874 100644 --- a/.flake8 +++ b/.flake8 @@ -16,7 +16,7 @@ # Generated by synthtool. DO NOT EDIT! [flake8] -ignore = E203, E266, E501, W503 +ignore = E203, E231, E266, E501, W503 exclude = # Exclude generated code. **/proto/** diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index 87dd006..9e0a935 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,4 +13,4 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:7cffbc10910c3ab1b852c05114a08d374c195a81cdec1d4a67a1d129331d0bfe + digest: sha256:462782b0b492346b2d9099aaff52206dd30bc8e031ea97082e6facecc2373244 From f7e41910dbe433cd8b7bd3c5b65a6514a39be67c Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Fri, 1 Apr 2022 00:34:23 +0000 Subject: [PATCH 03/19] chore(python): update .pre-commit-config.yaml to use black==22.3.0 (#83) Source-Link: https://github.com/googleapis/synthtool/commit/7804ade3daae0d66649bee8df6c55484c6580b8d Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:eede5672562a32821444a8e803fb984a6f61f2237ea3de229d2de24453f4ae7d --- .github/.OwlBot.lock.yaml | 3 ++- .pre-commit-config.yaml | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index 9e0a935..22cc254 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,4 +13,5 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:462782b0b492346b2d9099aaff52206dd30bc8e031ea97082e6facecc2373244 + digest: sha256:eede5672562a32821444a8e803fb984a6f61f2237ea3de229d2de24453f4ae7d +# created: 2022-03-30T23:44:26.560599165Z diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 62eb5a7..46d2371 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -22,7 +22,7 @@ repos: - id: end-of-file-fixer - id: check-yaml - repo: https://github.com/psf/black - rev: 19.10b0 + rev: 22.3.0 hooks: - id: black - repo: https://gitlab.com/pycqa/flake8 From cd01fdcf4dfe3521baea4e4c6bc61d222756fe57 Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Fri, 1 Apr 2022 02:14:27 +0000 Subject: [PATCH 04/19] chore(python): Enable size-label bot (#84) Source-Link: https://github.com/googleapis/synthtool/commit/06e82790dd719a165ad32b8a06f8f6ec3e3cae0f Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:b3500c053313dc34e07b1632ba9e4e589f4f77036a7cf39e1fe8906811ae0fce --- .github/.OwlBot.lock.yaml | 4 ++-- .github/auto-label.yaml | 2 ++ 2 files changed, 4 insertions(+), 2 deletions(-) create mode 100644 .github/auto-label.yaml diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index 22cc254..58a0b15 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,5 +13,5 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:eede5672562a32821444a8e803fb984a6f61f2237ea3de229d2de24453f4ae7d -# created: 2022-03-30T23:44:26.560599165Z + digest: sha256:b3500c053313dc34e07b1632ba9e4e589f4f77036a7cf39e1fe8906811ae0fce +# created: 2022-04-01T01:42:03.609279246Z diff --git a/.github/auto-label.yaml b/.github/auto-label.yaml new file mode 100644 index 0000000..09c8d73 --- /dev/null +++ b/.github/auto-label.yaml @@ -0,0 +1,2 @@ +requestsize: + enabled: true From 1c443a2dff9f814198808ea559a2eb6f37adda36 Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Fri, 1 Apr 2022 19:44:18 +0000 Subject: [PATCH 05/19] chore(python): refactor unit / system test dependency install (#85) Source-Link: https://github.com/googleapis/synthtool/commit/993985f0fc4b37152e588f0549bcbdaf34666023 Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:1894490910e891a385484514b22eb5133578897eb5b3c380e6d8ad475c6647cd --- .github/.OwlBot.lock.yaml | 4 +- noxfile.py | 105 ++++++++++++++++++++++++++++++-------- 2 files changed, 87 insertions(+), 22 deletions(-) diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index 58a0b15..fa57622 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,5 +13,5 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:b3500c053313dc34e07b1632ba9e4e589f4f77036a7cf39e1fe8906811ae0fce -# created: 2022-04-01T01:42:03.609279246Z + digest: sha256:1894490910e891a385484514b22eb5133578897eb5b3c380e6d8ad475c6647cd +# created: 2022-04-01T15:48:07.524222836Z diff --git a/noxfile.py b/noxfile.py index 3addb4e..6ee5e8a 100644 --- a/noxfile.py +++ b/noxfile.py @@ -20,16 +20,40 @@ import os import pathlib import shutil +import warnings import nox - BLACK_VERSION = "black==22.3.0" BLACK_PATHS = ["docs", "google", "tests", "noxfile.py", "setup.py"] DEFAULT_PYTHON_VERSION = "3.8" -SYSTEM_TEST_PYTHON_VERSIONS = ["3.8"] + UNIT_TEST_PYTHON_VERSIONS = ["3.6", "3.7", "3.8", "3.9", "3.10"] +UNIT_TEST_STANDARD_DEPENDENCIES = [ + "mock", + "asyncmock", + "pytest", + "pytest-cov", + "pytest-asyncio", +] +UNIT_TEST_EXTERNAL_DEPENDENCIES = [] +UNIT_TEST_LOCAL_DEPENDENCIES = [] +UNIT_TEST_DEPENDENCIES = [] +UNIT_TEST_EXTRAS = [] +UNIT_TEST_EXTRAS_BY_PYTHON = {} + +SYSTEM_TEST_PYTHON_VERSIONS = ["3.8"] +SYSTEM_TEST_STANDARD_DEPENDENCIES = [ + "mock", + "pytest", + "google-cloud-testutils", +] +SYSTEM_TEST_EXTERNAL_DEPENDENCIES = [] +SYSTEM_TEST_LOCAL_DEPENDENCIES = [] +SYSTEM_TEST_DEPENDENCIES = [] +SYSTEM_TEST_EXTRAS = [] +SYSTEM_TEST_EXTRAS_BY_PYTHON = {} CURRENT_DIRECTORY = pathlib.Path(__file__).parent.absolute() @@ -81,23 +105,41 @@ def lint_setup_py(session): session.run("python", "setup.py", "check", "--restructuredtext", "--strict") +def install_unittest_dependencies(session, *constraints): + standard_deps = UNIT_TEST_STANDARD_DEPENDENCIES + UNIT_TEST_DEPENDENCIES + session.install(*standard_deps, *constraints) + + if UNIT_TEST_EXTERNAL_DEPENDENCIES: + warnings.warn( + "'unit_test_external_dependencies' is deprecated. Instead, please " + "use 'unit_test_dependencies' or 'unit_test_local_dependencies'.", + DeprecationWarning, + ) + session.install(*UNIT_TEST_EXTERNAL_DEPENDENCIES, *constraints) + + if UNIT_TEST_LOCAL_DEPENDENCIES: + session.install(*UNIT_TEST_LOCAL_DEPENDENCIES, *constraints) + + if UNIT_TEST_EXTRAS_BY_PYTHON: + extras = UNIT_TEST_EXTRAS_BY_PYTHON.get(session.python, []) + elif UNIT_TEST_EXTRAS: + extras = UNIT_TEST_EXTRAS + else: + extras = [] + + if extras: + session.install("-e", f".[{','.join(extras)}]", *constraints) + else: + session.install("-e", ".", *constraints) + + def default(session): # Install all test dependencies, then install this package in-place. constraints_path = str( CURRENT_DIRECTORY / "testing" / f"constraints-{session.python}.txt" ) - session.install( - "mock", - "asyncmock", - "pytest", - "pytest-cov", - "pytest-asyncio", - "-c", - constraints_path, - ) - - session.install("-e", ".", "-c", constraints_path) + install_unittest_dependencies(session, "-c", constraints_path) # Run py.test against the unit tests. session.run( @@ -121,6 +163,35 @@ def unit(session): default(session) +def install_systemtest_dependencies(session, *constraints): + + # Use pre-release gRPC for system tests. + session.install("--pre", "grpcio") + + session.install(*SYSTEM_TEST_STANDARD_DEPENDENCIES, *constraints) + + if SYSTEM_TEST_EXTERNAL_DEPENDENCIES: + session.install(*SYSTEM_TEST_EXTERNAL_DEPENDENCIES, *constraints) + + if SYSTEM_TEST_LOCAL_DEPENDENCIES: + session.install("-e", *SYSTEM_TEST_LOCAL_DEPENDENCIES, *constraints) + + if SYSTEM_TEST_DEPENDENCIES: + session.install("-e", *SYSTEM_TEST_DEPENDENCIES, *constraints) + + if SYSTEM_TEST_EXTRAS_BY_PYTHON: + extras = SYSTEM_TEST_EXTRAS_BY_PYTHON.get(session.python, []) + elif SYSTEM_TEST_EXTRAS: + extras = SYSTEM_TEST_EXTRAS + else: + extras = [] + + if extras: + session.install("-e", f".[{','.join(extras)}]", *constraints) + else: + session.install("-e", ".", *constraints) + + @nox.session(python=SYSTEM_TEST_PYTHON_VERSIONS) def system(session): """Run the system test suite.""" @@ -143,13 +214,7 @@ def system(session): if not system_test_exists and not system_test_folder_exists: session.skip("System tests were not found") - # Use pre-release gRPC for system tests. - session.install("--pre", "grpcio") - - # Install all test dependencies, then install this package into the - # virtualenv's dist-packages. - session.install("mock", "pytest", "google-cloud-testutils", "-c", constraints_path) - session.install("-e", ".", "-c", constraints_path) + install_systemtest_dependencies(session, "-c", constraints_path) # Run py.test against the system tests. if system_test_exists: From b53ec3cad752ed7121db73a994595158be0212f7 Mon Sep 17 00:00:00 2001 From: Anthonios Partheniou Date: Mon, 4 Apr 2022 05:22:37 -0400 Subject: [PATCH 06/19] chore: allow releases on previous majors (#78) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * chore: allow releases on previous majors * 🦉 Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md Co-authored-by: Owl Bot --- .github/release-please.yml | 6 ++++++ owlbot.py | 2 ++ 2 files changed, 8 insertions(+) diff --git a/.github/release-please.yml b/.github/release-please.yml index 466597e..6def37a 100644 --- a/.github/release-please.yml +++ b/.github/release-please.yml @@ -1,2 +1,8 @@ releaseType: python handleGHRelease: true +# NOTE: this section is generated by synthtool.languages.python +# See https://github.com/googleapis/synthtool/blob/master/synthtool/languages/python.py +branches: +- branch: v0 + handleGHRelease: true + releaseType: python diff --git a/owlbot.py b/owlbot.py index 0f3e541..22cc59f 100644 --- a/owlbot.py +++ b/owlbot.py @@ -63,6 +63,8 @@ python.py_samples(skip_readmes=True) s.move(templated_files, excludes=[".coveragerc"]) # the microgenerator has a good coveragerc file +python.configure_previous_major_version_branches() + # ---------------------------------------------------------------------------- # Run blacken session # ---------------------------------------------------------------------------- From 10565766f4958526c661b73f36c756af284a2091 Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Wed, 6 Apr 2022 10:48:10 +0000 Subject: [PATCH 07/19] chore(python): add license header to auto-label.yaml (#86) Source-Link: https://github.com/googleapis/synthtool/commit/eb78c980b52c7c6746d2edb77d9cf7aaa99a2aab Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:8a5d3f6a2e43ed8293f34e06a2f56931d1e88a2694c3bb11b15df4eb256ad163 --- .github/.OwlBot.lock.yaml | 4 ++-- .github/auto-label.yaml | 13 +++++++++++++ 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index fa57622..bc893c9 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,5 +13,5 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:1894490910e891a385484514b22eb5133578897eb5b3c380e6d8ad475c6647cd -# created: 2022-04-01T15:48:07.524222836Z + digest: sha256:8a5d3f6a2e43ed8293f34e06a2f56931d1e88a2694c3bb11b15df4eb256ad163 +# created: 2022-04-06T10:30:21.687684602Z diff --git a/.github/auto-label.yaml b/.github/auto-label.yaml index 09c8d73..41bff0b 100644 --- a/.github/auto-label.yaml +++ b/.github/auto-label.yaml @@ -1,2 +1,15 @@ +# Copyright 2022 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. requestsize: enabled: true From bc49bbae677fe507518bfc4d8f46cd3a7705504a Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Mon, 11 Apr 2022 19:50:15 -0400 Subject: [PATCH 08/19] chore: Use gapic-generator-python 0.65.0 (#89) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * chore: Use gapic-generator-python 0.65.0 PiperOrigin-RevId: 440970084 Source-Link: https://github.com/googleapis/googleapis/commit/5e0a3d57254ab9857ccac77fc6ffade7b69a2dc7 Source-Link: https://github.com/googleapis/googleapis-gen/commit/b0c628a3fade768f225d76992791ea1ba2a881be Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiYjBjNjI4YTNmYWRlNzY4ZjIyNWQ3Njk5Mjc5MWVhMWJhMmE4ODFiZSJ9 * 🦉 Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md Co-authored-by: Owl Bot --- .../services/controller2/async_client.py | 11 +-- .../services/controller2/client.py | 5 +- .../services/controller2/transports/base.py | 11 ++- .../services/controller2/transports/grpc.py | 4 + .../services/debugger2/async_client.py | 14 ++-- .../debugger_v2/services/debugger2/client.py | 2 +- .../services/debugger2/transports/base.py | 17 +++-- .../services/debugger2/transports/grpc.py | 4 + google/cloud/debugger_v2/types/data.py | 4 +- .../gapic/debugger_v2/test_controller2.py | 75 ++++++++++++++----- .../unit/gapic/debugger_v2/test_debugger2.py | 75 ++++++++++++++----- 11 files changed, 152 insertions(+), 70 deletions(-) diff --git a/google/cloud/debugger_v2/services/controller2/async_client.py b/google/cloud/debugger_v2/services/controller2/async_client.py index 0a1c4ab..78ef5a7 100644 --- a/google/cloud/debugger_v2/services/controller2/async_client.py +++ b/google/cloud/debugger_v2/services/controller2/async_client.py @@ -16,7 +16,7 @@ from collections import OrderedDict import functools import re -from typing import Dict, Optional, Sequence, Tuple, Type, Union +from typing import Dict, Mapping, Optional, Sequence, Tuple, Type, Union import pkg_resources from google.api_core.client_options import ClientOptions @@ -240,7 +240,6 @@ async def register_debuggee( format. Agents must handle ``debuggee_id`` value changing upon re-registration. - .. code-block:: python from google.cloud import debugger_v2 @@ -340,7 +339,6 @@ async def list_active_breakpoints( breakpoints that are completed until the controller removes them from the active list to avoid setting those breakpoints again. - .. code-block:: python from google.cloud import debugger_v2 @@ -406,8 +404,7 @@ def sample_list_active_breakpoints(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -446,7 +443,6 @@ async def update_active_breakpoint( changes such as canonicalizing a value or snapping the location to the correct line of code. - .. code-block:: python from google.cloud import debugger_v2 @@ -526,8 +522,7 @@ def sample_update_active_breakpoint(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), diff --git a/google/cloud/debugger_v2/services/controller2/client.py b/google/cloud/debugger_v2/services/controller2/client.py index c3cfb1a..88d5595 100644 --- a/google/cloud/debugger_v2/services/controller2/client.py +++ b/google/cloud/debugger_v2/services/controller2/client.py @@ -16,7 +16,7 @@ from collections import OrderedDict import os import re -from typing import Dict, Optional, Sequence, Tuple, Type, Union +from typing import Dict, Mapping, Optional, Sequence, Tuple, Type, Union import pkg_resources from google.api_core import client_options as client_options_lib @@ -446,7 +446,6 @@ def register_debuggee( format. Agents must handle ``debuggee_id`` value changing upon re-registration. - .. code-block:: python from google.cloud import debugger_v2 @@ -546,7 +545,6 @@ def list_active_breakpoints( breakpoints that are completed until the controller removes them from the active list to avoid setting those breakpoints again. - .. code-block:: python from google.cloud import debugger_v2 @@ -642,7 +640,6 @@ def update_active_breakpoint( changes such as canonicalizing a value or snapping the location to the correct line of code. - .. code-block:: python from google.cloud import debugger_v2 diff --git a/google/cloud/debugger_v2/services/controller2/transports/base.py b/google/cloud/debugger_v2/services/controller2/transports/base.py index 1dce5c2..44f4be2 100644 --- a/google/cloud/debugger_v2/services/controller2/transports/base.py +++ b/google/cloud/debugger_v2/services/controller2/transports/base.py @@ -83,6 +83,7 @@ def __init__( always_use_jwt_access (Optional[bool]): Whether self signed JWT should be used for service account credentials. """ + # Save the hostname. Default to port 443 (HTTPS) if none is specified. if ":" not in host: host += ":443" @@ -135,8 +136,7 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -150,8 +150,7 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -205,5 +204,9 @@ def update_active_breakpoint( ]: raise NotImplementedError() + @property + def kind(self) -> str: + raise NotImplementedError() + __all__ = ("Controller2Transport",) diff --git a/google/cloud/debugger_v2/services/controller2/transports/grpc.py b/google/cloud/debugger_v2/services/controller2/transports/grpc.py index f7a02d9..07270d6 100644 --- a/google/cloud/debugger_v2/services/controller2/transports/grpc.py +++ b/google/cloud/debugger_v2/services/controller2/transports/grpc.py @@ -369,5 +369,9 @@ def update_active_breakpoint( def close(self): self.grpc_channel.close() + @property + def kind(self) -> str: + return "grpc" + __all__ = ("Controller2GrpcTransport",) diff --git a/google/cloud/debugger_v2/services/debugger2/async_client.py b/google/cloud/debugger_v2/services/debugger2/async_client.py index 31c7b86..22de4ea 100644 --- a/google/cloud/debugger_v2/services/debugger2/async_client.py +++ b/google/cloud/debugger_v2/services/debugger2/async_client.py @@ -16,7 +16,7 @@ from collections import OrderedDict import functools import re -from typing import Dict, Optional, Sequence, Tuple, Type, Union +from typing import Dict, Mapping, Optional, Sequence, Tuple, Type, Union import pkg_resources from google.api_core.client_options import ClientOptions @@ -417,8 +417,7 @@ def sample_get_breakpoint(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -529,8 +528,7 @@ def sample_delete_breakpoint(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -634,8 +632,7 @@ def sample_list_breakpoints(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -742,8 +739,7 @@ def sample_list_debuggees(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), diff --git a/google/cloud/debugger_v2/services/debugger2/client.py b/google/cloud/debugger_v2/services/debugger2/client.py index eed6811..cba0b05 100644 --- a/google/cloud/debugger_v2/services/debugger2/client.py +++ b/google/cloud/debugger_v2/services/debugger2/client.py @@ -16,7 +16,7 @@ from collections import OrderedDict import os import re -from typing import Dict, Optional, Sequence, Tuple, Type, Union +from typing import Dict, Mapping, Optional, Sequence, Tuple, Type, Union import pkg_resources from google.api_core import client_options as client_options_lib diff --git a/google/cloud/debugger_v2/services/debugger2/transports/base.py b/google/cloud/debugger_v2/services/debugger2/transports/base.py index dfb1342..afc8898 100644 --- a/google/cloud/debugger_v2/services/debugger2/transports/base.py +++ b/google/cloud/debugger_v2/services/debugger2/transports/base.py @@ -84,6 +84,7 @@ def __init__( always_use_jwt_access (Optional[bool]): Whether self signed JWT should be used for service account credentials. """ + # Save the hostname. Default to port 443 (HTTPS) if none is specified. if ":" not in host: host += ":443" @@ -136,8 +137,7 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -151,8 +151,7 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -166,8 +165,7 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -181,8 +179,7 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.DeadlineExceeded, - core_exceptions.ServiceUnavailable, + core_exceptions.GoogleAPICallError, ), deadline=600.0, ), @@ -254,5 +251,9 @@ def list_debuggees( ]: raise NotImplementedError() + @property + def kind(self) -> str: + raise NotImplementedError() + __all__ = ("Debugger2Transport",) diff --git a/google/cloud/debugger_v2/services/debugger2/transports/grpc.py b/google/cloud/debugger_v2/services/debugger2/transports/grpc.py index 83bd57f..c4f7223 100644 --- a/google/cloud/debugger_v2/services/debugger2/transports/grpc.py +++ b/google/cloud/debugger_v2/services/debugger2/transports/grpc.py @@ -373,5 +373,9 @@ def list_debuggees( def close(self): self.grpc_channel.close() + @property + def kind(self) -> str: + return "grpc" + __all__ = ("Debugger2GrpcTransport",) diff --git a/google/cloud/debugger_v2/types/data.py b/google/cloud/debugger_v2/types/data.py index 2e9e7e2..3d3ecf7 100644 --- a/google/cloud/debugger_v2/types/data.py +++ b/google/cloud/debugger_v2/types/data.py @@ -427,7 +427,7 @@ class Breakpoint(proto.Message): their name from the referencing variable. The effective variable is a merge of the referencing variable and the referenced variable. - labels (Sequence[google.cloud.debugger_v2.types.Breakpoint.LabelsEntry]): + labels (Mapping[str, str]): A set of custom breakpoint properties, populated by the agent, to be displayed to the user. @@ -579,7 +579,7 @@ class Debuggee(proto.Message): References to the locations and revisions of the source code used in the deployed application. - labels (Sequence[google.cloud.debugger_v2.types.Debuggee.LabelsEntry]): + labels (Mapping[str, str]): A set of custom debuggee properties, populated by the agent, to be displayed to the user. diff --git a/tests/unit/gapic/debugger_v2/test_controller2.py b/tests/unit/gapic/debugger_v2/test_controller2.py index b4faf5b..6ead507 100644 --- a/tests/unit/gapic/debugger_v2/test_controller2.py +++ b/tests/unit/gapic/debugger_v2/test_controller2.py @@ -85,24 +85,24 @@ def test__get_default_mtls_endpoint(): @pytest.mark.parametrize( - "client_class", + "client_class,transport_name", [ - Controller2Client, - Controller2AsyncClient, + (Controller2Client, "grpc"), + (Controller2AsyncClient, "grpc_asyncio"), ], ) -def test_controller2_client_from_service_account_info(client_class): +def test_controller2_client_from_service_account_info(client_class, transport_name): creds = ga_credentials.AnonymousCredentials() with mock.patch.object( service_account.Credentials, "from_service_account_info" ) as factory: factory.return_value = creds info = {"valid": True} - client = client_class.from_service_account_info(info) + client = client_class.from_service_account_info(info, transport=transport_name) assert client.transport._credentials == creds assert isinstance(client, client_class) - assert client.transport._host == "clouddebugger.googleapis.com:443" + assert client.transport._host == ("clouddebugger.googleapis.com:443") @pytest.mark.parametrize( @@ -131,27 +131,31 @@ def test_controller2_client_service_account_always_use_jwt( @pytest.mark.parametrize( - "client_class", + "client_class,transport_name", [ - Controller2Client, - Controller2AsyncClient, + (Controller2Client, "grpc"), + (Controller2AsyncClient, "grpc_asyncio"), ], ) -def test_controller2_client_from_service_account_file(client_class): +def test_controller2_client_from_service_account_file(client_class, transport_name): creds = ga_credentials.AnonymousCredentials() with mock.patch.object( service_account.Credentials, "from_service_account_file" ) as factory: factory.return_value = creds - client = client_class.from_service_account_file("dummy/file/path.json") + client = client_class.from_service_account_file( + "dummy/file/path.json", transport=transport_name + ) assert client.transport._credentials == creds assert isinstance(client, client_class) - client = client_class.from_service_account_json("dummy/file/path.json") + client = client_class.from_service_account_json( + "dummy/file/path.json", transport=transport_name + ) assert client.transport._credentials == creds assert isinstance(client, client_class) - assert client.transport._host == "clouddebugger.googleapis.com:443" + assert client.transport._host == ("clouddebugger.googleapis.com:443") def test_controller2_client_get_transport_class(): @@ -1262,6 +1266,19 @@ def test_transport_adc(transport_class): adc.assert_called_once() +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + ], +) +def test_transport_kind(transport_name): + transport = Controller2Client.get_transport_class(transport_name)( + credentials=ga_credentials.AnonymousCredentials(), + ) + assert transport.kind == transport_name + + def test_transport_grpc_default(): # A client should use the gRPC transport by default. client = Controller2Client( @@ -1306,6 +1323,14 @@ def test_controller2_base_transport(): with pytest.raises(NotImplementedError): transport.close() + # Catch all for all remaining methods and properties + remainder = [ + "kind", + ] + for r in remainder: + with pytest.raises(NotImplementedError): + getattr(transport, r)() + def test_controller2_base_transport_with_credentials_file(): # Instantiate the base transport with a credentials file @@ -1460,24 +1485,40 @@ def test_controller2_grpc_transport_client_cert_source_for_mtls(transport_class) ) -def test_controller2_host_no_port(): +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "grpc_asyncio", + ], +) +def test_controller2_host_no_port(transport_name): client = Controller2Client( credentials=ga_credentials.AnonymousCredentials(), client_options=client_options.ClientOptions( api_endpoint="clouddebugger.googleapis.com" ), + transport=transport_name, ) - assert client.transport._host == "clouddebugger.googleapis.com:443" + assert client.transport._host == ("clouddebugger.googleapis.com:443") -def test_controller2_host_with_port(): +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "grpc_asyncio", + ], +) +def test_controller2_host_with_port(transport_name): client = Controller2Client( credentials=ga_credentials.AnonymousCredentials(), client_options=client_options.ClientOptions( api_endpoint="clouddebugger.googleapis.com:8000" ), + transport=transport_name, ) - assert client.transport._host == "clouddebugger.googleapis.com:8000" + assert client.transport._host == ("clouddebugger.googleapis.com:8000") def test_controller2_grpc_transport_channel(): diff --git a/tests/unit/gapic/debugger_v2/test_debugger2.py b/tests/unit/gapic/debugger_v2/test_debugger2.py index 5db1005..fab5ff2 100644 --- a/tests/unit/gapic/debugger_v2/test_debugger2.py +++ b/tests/unit/gapic/debugger_v2/test_debugger2.py @@ -82,24 +82,24 @@ def test__get_default_mtls_endpoint(): @pytest.mark.parametrize( - "client_class", + "client_class,transport_name", [ - Debugger2Client, - Debugger2AsyncClient, + (Debugger2Client, "grpc"), + (Debugger2AsyncClient, "grpc_asyncio"), ], ) -def test_debugger2_client_from_service_account_info(client_class): +def test_debugger2_client_from_service_account_info(client_class, transport_name): creds = ga_credentials.AnonymousCredentials() with mock.patch.object( service_account.Credentials, "from_service_account_info" ) as factory: factory.return_value = creds info = {"valid": True} - client = client_class.from_service_account_info(info) + client = client_class.from_service_account_info(info, transport=transport_name) assert client.transport._credentials == creds assert isinstance(client, client_class) - assert client.transport._host == "clouddebugger.googleapis.com:443" + assert client.transport._host == ("clouddebugger.googleapis.com:443") @pytest.mark.parametrize( @@ -128,27 +128,31 @@ def test_debugger2_client_service_account_always_use_jwt( @pytest.mark.parametrize( - "client_class", + "client_class,transport_name", [ - Debugger2Client, - Debugger2AsyncClient, + (Debugger2Client, "grpc"), + (Debugger2AsyncClient, "grpc_asyncio"), ], ) -def test_debugger2_client_from_service_account_file(client_class): +def test_debugger2_client_from_service_account_file(client_class, transport_name): creds = ga_credentials.AnonymousCredentials() with mock.patch.object( service_account.Credentials, "from_service_account_file" ) as factory: factory.return_value = creds - client = client_class.from_service_account_file("dummy/file/path.json") + client = client_class.from_service_account_file( + "dummy/file/path.json", transport=transport_name + ) assert client.transport._credentials == creds assert isinstance(client, client_class) - client = client_class.from_service_account_json("dummy/file/path.json") + client = client_class.from_service_account_json( + "dummy/file/path.json", transport=transport_name + ) assert client.transport._credentials == creds assert isinstance(client, client_class) - assert client.transport._host == "clouddebugger.googleapis.com:443" + assert client.transport._host == ("clouddebugger.googleapis.com:443") def test_debugger2_client_get_transport_class(): @@ -1627,6 +1631,19 @@ def test_transport_adc(transport_class): adc.assert_called_once() +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + ], +) +def test_transport_kind(transport_name): + transport = Debugger2Client.get_transport_class(transport_name)( + credentials=ga_credentials.AnonymousCredentials(), + ) + assert transport.kind == transport_name + + def test_transport_grpc_default(): # A client should use the gRPC transport by default. client = Debugger2Client( @@ -1673,6 +1690,14 @@ def test_debugger2_base_transport(): with pytest.raises(NotImplementedError): transport.close() + # Catch all for all remaining methods and properties + remainder = [ + "kind", + ] + for r in remainder: + with pytest.raises(NotImplementedError): + getattr(transport, r)() + def test_debugger2_base_transport_with_credentials_file(): # Instantiate the base transport with a credentials file @@ -1827,24 +1852,40 @@ def test_debugger2_grpc_transport_client_cert_source_for_mtls(transport_class): ) -def test_debugger2_host_no_port(): +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "grpc_asyncio", + ], +) +def test_debugger2_host_no_port(transport_name): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), client_options=client_options.ClientOptions( api_endpoint="clouddebugger.googleapis.com" ), + transport=transport_name, ) - assert client.transport._host == "clouddebugger.googleapis.com:443" + assert client.transport._host == ("clouddebugger.googleapis.com:443") -def test_debugger2_host_with_port(): +@pytest.mark.parametrize( + "transport_name", + [ + "grpc", + "grpc_asyncio", + ], +) +def test_debugger2_host_with_port(transport_name): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), client_options=client_options.ClientOptions( api_endpoint="clouddebugger.googleapis.com:8000" ), + transport=transport_name, ) - assert client.transport._host == "clouddebugger.googleapis.com:8000" + assert client.transport._host == ("clouddebugger.googleapis.com:8000") def test_debugger2_grpc_transport_channel(): From 8d3a2be696c5bd0166b7a6eb62e319147056724a Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Wed, 13 Apr 2022 20:55:49 -0400 Subject: [PATCH 09/19] chore: use gapic-generator-python 0.65.1 (#91) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * chore: use gapic-generator-python 0.65.1 PiperOrigin-RevId: 441524537 Source-Link: https://github.com/googleapis/googleapis/commit/2a273915b3f70fe86c9d2a75470a0b83e48d0abf Source-Link: https://github.com/googleapis/googleapis-gen/commit/ab6756a48c89b5bcb9fb73443cb8e55d574f4643 Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiYWI2NzU2YTQ4Yzg5YjViY2I5ZmI3MzQ0M2NiOGU1NWQ1NzRmNDY0MyJ9 * 🦉 Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md Co-authored-by: Owl Bot --- .../services/controller2/async_client.py | 6 +- .../services/controller2/transports/base.py | 6 +- .../services/debugger2/async_client.py | 12 +- .../services/debugger2/transports/base.py | 12 +- .../snippet_metadata_debugger_v2.json | 720 +++++++++++++++++- 5 files changed, 712 insertions(+), 44 deletions(-) diff --git a/google/cloud/debugger_v2/services/controller2/async_client.py b/google/cloud/debugger_v2/services/controller2/async_client.py index 78ef5a7..6799237 100644 --- a/google/cloud/debugger_v2/services/controller2/async_client.py +++ b/google/cloud/debugger_v2/services/controller2/async_client.py @@ -404,7 +404,8 @@ def sample_list_active_breakpoints(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), @@ -522,7 +523,8 @@ def sample_update_active_breakpoint(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), diff --git a/google/cloud/debugger_v2/services/controller2/transports/base.py b/google/cloud/debugger_v2/services/controller2/transports/base.py index 44f4be2..5cabe0e 100644 --- a/google/cloud/debugger_v2/services/controller2/transports/base.py +++ b/google/cloud/debugger_v2/services/controller2/transports/base.py @@ -136,7 +136,8 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), @@ -150,7 +151,8 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), diff --git a/google/cloud/debugger_v2/services/debugger2/async_client.py b/google/cloud/debugger_v2/services/debugger2/async_client.py index 22de4ea..77822c6 100644 --- a/google/cloud/debugger_v2/services/debugger2/async_client.py +++ b/google/cloud/debugger_v2/services/debugger2/async_client.py @@ -417,7 +417,8 @@ def sample_get_breakpoint(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), @@ -528,7 +529,8 @@ def sample_delete_breakpoint(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), @@ -632,7 +634,8 @@ def sample_list_breakpoints(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), @@ -739,7 +742,8 @@ def sample_list_debuggees(): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), diff --git a/google/cloud/debugger_v2/services/debugger2/transports/base.py b/google/cloud/debugger_v2/services/debugger2/transports/base.py index afc8898..d48dfd6 100644 --- a/google/cloud/debugger_v2/services/debugger2/transports/base.py +++ b/google/cloud/debugger_v2/services/debugger2/transports/base.py @@ -137,7 +137,8 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), @@ -151,7 +152,8 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), @@ -165,7 +167,8 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), @@ -179,7 +182,8 @@ def _prep_wrapped_messages(self, client_info): maximum=60.0, multiplier=1.3, predicate=retries.if_exception_type( - core_exceptions.GoogleAPICallError, + core_exceptions.DeadlineExceeded, + core_exceptions.ServiceUnavailable, ), deadline=600.0, ), diff --git a/samples/generated_samples/snippet_metadata_debugger_v2.json b/samples/generated_samples/snippet_metadata_debugger_v2.json index eafbe07..f1dcd45 100644 --- a/samples/generated_samples/snippet_metadata_debugger_v2.json +++ b/samples/generated_samples/snippet_metadata_debugger_v2.json @@ -1,16 +1,61 @@ { + "clientLibrary": { + "apis": [ + { + "id": "google.devtools.clouddebugger.v2", + "version": "v2" + } + ], + "language": "PYTHON", + "name": "google-cloud-debugger-client" + }, "snippets": [ { + "canonical": true, "clientMethod": { "async": true, + "client": { + "fullName": "google.cloud.debugger_v2.Controller2AsyncClient", + "shortName": "Controller2AsyncClient" + }, + "fullName": "google.cloud.debugger_v2.Controller2AsyncClient.list_active_breakpoints", "method": { + "fullName": "google.devtools.clouddebugger.v2.Controller2.ListActiveBreakpoints", "service": { + "fullName": "google.devtools.clouddebugger.v2.Controller2", "shortName": "Controller2" }, "shortName": "ListActiveBreakpoints" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.ListActiveBreakpointsRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.ListActiveBreakpointsResponse", + "shortName": "list_active_breakpoints" }, + "description": "Sample for ListActiveBreakpoints", "file": "clouddebugger_v2_generated_controller2_list_active_breakpoints_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Controller2_ListActiveBreakpoints_async", "segments": [ { @@ -43,18 +88,54 @@ "start": 42, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_controller2_list_active_breakpoints_async.py" }, { + "canonical": true, "clientMethod": { + "client": { + "fullName": "google.cloud.debugger_v2.Controller2Client", + "shortName": "Controller2Client" + }, + "fullName": "google.cloud.debugger_v2.Controller2Client.list_active_breakpoints", "method": { + "fullName": "google.devtools.clouddebugger.v2.Controller2.ListActiveBreakpoints", "service": { + "fullName": "google.devtools.clouddebugger.v2.Controller2", "shortName": "Controller2" }, "shortName": "ListActiveBreakpoints" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.ListActiveBreakpointsRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.ListActiveBreakpointsResponse", + "shortName": "list_active_breakpoints" }, + "description": "Sample for ListActiveBreakpoints", "file": "clouddebugger_v2_generated_controller2_list_active_breakpoints_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Controller2_ListActiveBreakpoints_sync", "segments": [ { @@ -87,19 +168,55 @@ "start": 42, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_controller2_list_active_breakpoints_sync.py" }, { + "canonical": true, "clientMethod": { "async": true, + "client": { + "fullName": "google.cloud.debugger_v2.Controller2AsyncClient", + "shortName": "Controller2AsyncClient" + }, + "fullName": "google.cloud.debugger_v2.Controller2AsyncClient.register_debuggee", "method": { + "fullName": "google.devtools.clouddebugger.v2.Controller2.RegisterDebuggee", "service": { + "fullName": "google.devtools.clouddebugger.v2.Controller2", "shortName": "Controller2" }, "shortName": "RegisterDebuggee" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.RegisterDebuggeeRequest" + }, + { + "name": "debuggee", + "type": "google.cloud.debugger_v2.types.Debuggee" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.RegisterDebuggeeResponse", + "shortName": "register_debuggee" }, + "description": "Sample for RegisterDebuggee", "file": "clouddebugger_v2_generated_controller2_register_debuggee_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Controller2_RegisterDebuggee_async", "segments": [ { @@ -132,18 +249,54 @@ "start": 41, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_controller2_register_debuggee_async.py" }, { + "canonical": true, "clientMethod": { + "client": { + "fullName": "google.cloud.debugger_v2.Controller2Client", + "shortName": "Controller2Client" + }, + "fullName": "google.cloud.debugger_v2.Controller2Client.register_debuggee", "method": { + "fullName": "google.devtools.clouddebugger.v2.Controller2.RegisterDebuggee", "service": { + "fullName": "google.devtools.clouddebugger.v2.Controller2", "shortName": "Controller2" }, "shortName": "RegisterDebuggee" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.RegisterDebuggeeRequest" + }, + { + "name": "debuggee", + "type": "google.cloud.debugger_v2.types.Debuggee" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.RegisterDebuggeeResponse", + "shortName": "register_debuggee" }, + "description": "Sample for RegisterDebuggee", "file": "clouddebugger_v2_generated_controller2_register_debuggee_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Controller2_RegisterDebuggee_sync", "segments": [ { @@ -176,19 +329,59 @@ "start": 41, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_controller2_register_debuggee_sync.py" }, { + "canonical": true, "clientMethod": { "async": true, + "client": { + "fullName": "google.cloud.debugger_v2.Controller2AsyncClient", + "shortName": "Controller2AsyncClient" + }, + "fullName": "google.cloud.debugger_v2.Controller2AsyncClient.update_active_breakpoint", "method": { + "fullName": "google.devtools.clouddebugger.v2.Controller2.UpdateActiveBreakpoint", "service": { + "fullName": "google.devtools.clouddebugger.v2.Controller2", "shortName": "Controller2" }, "shortName": "UpdateActiveBreakpoint" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.UpdateActiveBreakpointRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "breakpoint_", + "type": "google.cloud.debugger_v2.types.Breakpoint" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.UpdateActiveBreakpointResponse", + "shortName": "update_active_breakpoint" }, + "description": "Sample for UpdateActiveBreakpoint", "file": "clouddebugger_v2_generated_controller2_update_active_breakpoint_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Controller2_UpdateActiveBreakpoint_async", "segments": [ { @@ -221,18 +414,58 @@ "start": 42, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_controller2_update_active_breakpoint_async.py" }, { + "canonical": true, "clientMethod": { + "client": { + "fullName": "google.cloud.debugger_v2.Controller2Client", + "shortName": "Controller2Client" + }, + "fullName": "google.cloud.debugger_v2.Controller2Client.update_active_breakpoint", "method": { + "fullName": "google.devtools.clouddebugger.v2.Controller2.UpdateActiveBreakpoint", "service": { + "fullName": "google.devtools.clouddebugger.v2.Controller2", "shortName": "Controller2" }, "shortName": "UpdateActiveBreakpoint" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.UpdateActiveBreakpointRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "breakpoint_", + "type": "google.cloud.debugger_v2.types.Breakpoint" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.UpdateActiveBreakpointResponse", + "shortName": "update_active_breakpoint" }, + "description": "Sample for UpdateActiveBreakpoint", "file": "clouddebugger_v2_generated_controller2_update_active_breakpoint_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Controller2_UpdateActiveBreakpoint_sync", "segments": [ { @@ -265,19 +498,62 @@ "start": 42, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_controller2_update_active_breakpoint_sync.py" }, { + "canonical": true, "clientMethod": { "async": true, + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient", + "shortName": "Debugger2AsyncClient" + }, + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient.delete_breakpoint", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.DeleteBreakpoint", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "DeleteBreakpoint" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.DeleteBreakpointRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "breakpoint_id", + "type": "str" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "shortName": "delete_breakpoint" }, + "description": "Sample for DeleteBreakpoint", "file": "clouddebugger_v2_generated_debugger2_delete_breakpoint_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_DeleteBreakpoint_async", "segments": [ { @@ -308,18 +584,61 @@ "end": 45, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_delete_breakpoint_async.py" }, { + "canonical": true, "clientMethod": { + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2Client", + "shortName": "Debugger2Client" + }, + "fullName": "google.cloud.debugger_v2.Debugger2Client.delete_breakpoint", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.DeleteBreakpoint", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "DeleteBreakpoint" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.DeleteBreakpointRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "breakpoint_id", + "type": "str" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "shortName": "delete_breakpoint" }, + "description": "Sample for DeleteBreakpoint", "file": "clouddebugger_v2_generated_debugger2_delete_breakpoint_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_DeleteBreakpoint_sync", "segments": [ { @@ -350,19 +669,63 @@ "end": 45, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_delete_breakpoint_sync.py" }, { + "canonical": true, "clientMethod": { "async": true, + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient", + "shortName": "Debugger2AsyncClient" + }, + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient.get_breakpoint", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.GetBreakpoint", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "GetBreakpoint" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.GetBreakpointRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "breakpoint_id", + "type": "str" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.GetBreakpointResponse", + "shortName": "get_breakpoint" }, + "description": "Sample for GetBreakpoint", "file": "clouddebugger_v2_generated_debugger2_get_breakpoint_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_GetBreakpoint_async", "segments": [ { @@ -395,18 +758,62 @@ "start": 44, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_get_breakpoint_async.py" }, { + "canonical": true, "clientMethod": { + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2Client", + "shortName": "Debugger2Client" + }, + "fullName": "google.cloud.debugger_v2.Debugger2Client.get_breakpoint", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.GetBreakpoint", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "GetBreakpoint" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.GetBreakpointRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "breakpoint_id", + "type": "str" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.GetBreakpointResponse", + "shortName": "get_breakpoint" }, + "description": "Sample for GetBreakpoint", "file": "clouddebugger_v2_generated_debugger2_get_breakpoint_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_GetBreakpoint_sync", "segments": [ { @@ -439,19 +846,59 @@ "start": 44, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_get_breakpoint_sync.py" }, { + "canonical": true, "clientMethod": { "async": true, + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient", + "shortName": "Debugger2AsyncClient" + }, + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient.list_breakpoints", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.ListBreakpoints", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "ListBreakpoints" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.ListBreakpointsRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.ListBreakpointsResponse", + "shortName": "list_breakpoints" }, + "description": "Sample for ListBreakpoints", "file": "clouddebugger_v2_generated_debugger2_list_breakpoints_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_ListBreakpoints_async", "segments": [ { @@ -484,18 +931,58 @@ "start": 43, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_list_breakpoints_async.py" }, { + "canonical": true, "clientMethod": { + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2Client", + "shortName": "Debugger2Client" + }, + "fullName": "google.cloud.debugger_v2.Debugger2Client.list_breakpoints", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.ListBreakpoints", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "ListBreakpoints" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.ListBreakpointsRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.ListBreakpointsResponse", + "shortName": "list_breakpoints" }, + "description": "Sample for ListBreakpoints", "file": "clouddebugger_v2_generated_debugger2_list_breakpoints_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_ListBreakpoints_sync", "segments": [ { @@ -528,19 +1015,59 @@ "start": 43, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_list_breakpoints_sync.py" }, { + "canonical": true, "clientMethod": { "async": true, + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient", + "shortName": "Debugger2AsyncClient" + }, + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient.list_debuggees", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.ListDebuggees", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "ListDebuggees" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.ListDebuggeesRequest" + }, + { + "name": "project", + "type": "str" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.ListDebuggeesResponse", + "shortName": "list_debuggees" }, + "description": "Sample for ListDebuggees", "file": "clouddebugger_v2_generated_debugger2_list_debuggees_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_ListDebuggees_async", "segments": [ { @@ -573,18 +1100,58 @@ "start": 43, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_list_debuggees_async.py" }, { + "canonical": true, "clientMethod": { + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2Client", + "shortName": "Debugger2Client" + }, + "fullName": "google.cloud.debugger_v2.Debugger2Client.list_debuggees", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.ListDebuggees", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "ListDebuggees" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.ListDebuggeesRequest" + }, + { + "name": "project", + "type": "str" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.ListDebuggeesResponse", + "shortName": "list_debuggees" }, + "description": "Sample for ListDebuggees", "file": "clouddebugger_v2_generated_debugger2_list_debuggees_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_ListDebuggees_sync", "segments": [ { @@ -617,19 +1184,63 @@ "start": 43, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_list_debuggees_sync.py" }, { + "canonical": true, "clientMethod": { "async": true, + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient", + "shortName": "Debugger2AsyncClient" + }, + "fullName": "google.cloud.debugger_v2.Debugger2AsyncClient.set_breakpoint", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.SetBreakpoint", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "SetBreakpoint" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.SetBreakpointRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "breakpoint_", + "type": "google.cloud.debugger_v2.types.Breakpoint" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.SetBreakpointResponse", + "shortName": "set_breakpoint" }, + "description": "Sample for SetBreakpoint", "file": "clouddebugger_v2_generated_debugger2_set_breakpoint_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_SetBreakpoint_async", "segments": [ { @@ -662,18 +1273,62 @@ "start": 43, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_set_breakpoint_async.py" }, { + "canonical": true, "clientMethod": { + "client": { + "fullName": "google.cloud.debugger_v2.Debugger2Client", + "shortName": "Debugger2Client" + }, + "fullName": "google.cloud.debugger_v2.Debugger2Client.set_breakpoint", "method": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2.SetBreakpoint", "service": { + "fullName": "google.devtools.clouddebugger.v2.Debugger2", "shortName": "Debugger2" }, "shortName": "SetBreakpoint" - } + }, + "parameters": [ + { + "name": "request", + "type": "google.cloud.debugger_v2.types.SetBreakpointRequest" + }, + { + "name": "debuggee_id", + "type": "str" + }, + { + "name": "breakpoint_", + "type": "google.cloud.debugger_v2.types.Breakpoint" + }, + { + "name": "client_version", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, str]" + } + ], + "resultType": "google.cloud.debugger_v2.types.SetBreakpointResponse", + "shortName": "set_breakpoint" }, + "description": "Sample for SetBreakpoint", "file": "clouddebugger_v2_generated_debugger2_set_breakpoint_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", "regionTag": "clouddebugger_v2_generated_Debugger2_SetBreakpoint_sync", "segments": [ { @@ -706,7 +1361,8 @@ "start": 43, "type": "RESPONSE_HANDLING" } - ] + ], + "title": "clouddebugger_v2_generated_debugger2_set_breakpoint_sync.py" } ] } From a3a28f46670066fbdd506d77a1da6172876683eb Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Wed, 20 Apr 2022 20:16:20 -0400 Subject: [PATCH 10/19] chore(python): add nox session to sort python imports (#92) Source-Link: https://github.com/googleapis/synthtool/commit/1b71c10e20de7ed3f97f692f99a0e3399b67049f Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:00c9d764fd1cd56265f12a5ef4b99a0c9e87cf261018099141e2ca5158890416 Co-authored-by: Owl Bot --- .github/.OwlBot.lock.yaml | 4 ++-- noxfile.py | 27 ++++++++++++++++++++++++--- 2 files changed, 26 insertions(+), 5 deletions(-) diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index bc893c9..7c454ab 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,5 +13,5 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:8a5d3f6a2e43ed8293f34e06a2f56931d1e88a2694c3bb11b15df4eb256ad163 -# created: 2022-04-06T10:30:21.687684602Z + digest: sha256:00c9d764fd1cd56265f12a5ef4b99a0c9e87cf261018099141e2ca5158890416 +# created: 2022-04-20T23:42:53.970438194Z diff --git a/noxfile.py b/noxfile.py index 6ee5e8a..92da31f 100644 --- a/noxfile.py +++ b/noxfile.py @@ -25,7 +25,8 @@ import nox BLACK_VERSION = "black==22.3.0" -BLACK_PATHS = ["docs", "google", "tests", "noxfile.py", "setup.py"] +ISORT_VERSION = "isort==5.10.1" +LINT_PATHS = ["docs", "google", "tests", "noxfile.py", "setup.py"] DEFAULT_PYTHON_VERSION = "3.8" @@ -83,7 +84,7 @@ def lint(session): session.run( "black", "--check", - *BLACK_PATHS, + *LINT_PATHS, ) session.run("flake8", "google", "tests") @@ -94,7 +95,27 @@ def blacken(session): session.install(BLACK_VERSION) session.run( "black", - *BLACK_PATHS, + *LINT_PATHS, + ) + + +@nox.session(python=DEFAULT_PYTHON_VERSION) +def format(session): + """ + Run isort to sort imports. Then run black + to format code to uniform standard. + """ + session.install(BLACK_VERSION, ISORT_VERSION) + # Use the --fss option to sort imports using strict alphabetical order. + # See https://pycqa.github.io/isort/docs/configuration/options.html#force-sort-within-sections + session.run( + "isort", + "--fss", + *LINT_PATHS, + ) + session.run( + "black", + *LINT_PATHS, ) From cc76d5949f8e22b2f8c4c51ecad5d6c974d48b4e Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Thu, 21 Apr 2022 13:22:05 -0400 Subject: [PATCH 11/19] chore(python): use ubuntu 22.04 in docs image (#94) Source-Link: https://github.com/googleapis/synthtool/commit/f15cc72fb401b4861cedebb10af74afe428fb1f8 Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:bc5eed3804aec2f05fad42aacf973821d9500c174015341f721a984a0825b6fd Co-authored-by: Owl Bot --- .github/.OwlBot.lock.yaml | 4 ++-- .kokoro/docker/docs/Dockerfile | 20 ++++++++++++++++++-- 2 files changed, 20 insertions(+), 4 deletions(-) diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index 7c454ab..64f82d6 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,5 +13,5 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:00c9d764fd1cd56265f12a5ef4b99a0c9e87cf261018099141e2ca5158890416 -# created: 2022-04-20T23:42:53.970438194Z + digest: sha256:bc5eed3804aec2f05fad42aacf973821d9500c174015341f721a984a0825b6fd +# created: 2022-04-21T15:43:16.246106921Z diff --git a/.kokoro/docker/docs/Dockerfile b/.kokoro/docker/docs/Dockerfile index 4e1b1fb..238b87b 100644 --- a/.kokoro/docker/docs/Dockerfile +++ b/.kokoro/docker/docs/Dockerfile @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -from ubuntu:20.04 +from ubuntu:22.04 ENV DEBIAN_FRONTEND noninteractive @@ -60,8 +60,24 @@ RUN apt-get update \ && rm -rf /var/lib/apt/lists/* \ && rm -f /var/cache/apt/archives/*.deb +###################### Install python 3.8.11 + +# Download python 3.8.11 +RUN wget https://www.python.org/ftp/python/3.8.11/Python-3.8.11.tgz + +# Extract files +RUN tar -xvf Python-3.8.11.tgz + +# Install python 3.8.11 +RUN ./Python-3.8.11/configure --enable-optimizations +RUN make altinstall + +###################### Install pip RUN wget -O /tmp/get-pip.py 'https://bootstrap.pypa.io/get-pip.py' \ - && python3.8 /tmp/get-pip.py \ + && python3 /tmp/get-pip.py \ && rm /tmp/get-pip.py +# Test pip +RUN python3 -m pip + CMD ["python3.8"] From f855cbcc56014780ab18f1b6b8857f666c3afb93 Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Thu, 28 Apr 2022 15:16:33 -0400 Subject: [PATCH 12/19] chore: use gapic-generator-python 0.65.2 (#95) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * chore: use gapic-generator-python 0.65.2 PiperOrigin-RevId: 444333013 Source-Link: https://github.com/googleapis/googleapis/commit/f91b6cf82e929280f6562f6110957c654bd9e2e6 Source-Link: https://github.com/googleapis/googleapis-gen/commit/16eb36095c294e712c74a1bf23550817b42174e5 Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiMTZlYjM2MDk1YzI5NGU3MTJjNzRhMWJmMjM1NTA4MTdiNDIxNzRlNSJ9 * 🦉 Updates from OwlBot post-processor See https://github.com/googleapis/repo-automation-bots/blob/main/packages/owl-bot/README.md * add replacement in owlbot.py to use correct attribute Co-authored-by: Owl Bot Co-authored-by: Anthonios Partheniou --- .../services/controller2/async_client.py | 37 ++- .../services/controller2/client.py | 19 ++ .../services/debugger2/async_client.py | 68 +++-- .../debugger_v2/services/debugger2/client.py | 38 +++ owlbot.py | 9 + .../gapic/debugger_v2/test_controller2.py | 132 +++++++++ .../unit/gapic/debugger_v2/test_debugger2.py | 250 ++++++++++++++++++ 7 files changed, 529 insertions(+), 24 deletions(-) diff --git a/google/cloud/debugger_v2/services/controller2/async_client.py b/google/cloud/debugger_v2/services/controller2/async_client.py index 6799237..8f6c5a4 100644 --- a/google/cloud/debugger_v2/services/controller2/async_client.py +++ b/google/cloud/debugger_v2/services/controller2/async_client.py @@ -244,16 +244,16 @@ async def register_debuggee( from google.cloud import debugger_v2 - def sample_register_debuggee(): + async def sample_register_debuggee(): # Create a client - client = debugger_v2.Controller2Client() + client = debugger_v2.Controller2AsyncClient() # Initialize request argument(s) request = debugger_v2.RegisterDebuggeeRequest( ) # Make the request - response = client.register_debuggee(request=request) + response = await client.register_debuggee(request=request) # Handle the response print(response) @@ -343,9 +343,9 @@ async def list_active_breakpoints( from google.cloud import debugger_v2 - def sample_list_active_breakpoints(): + async def sample_list_active_breakpoints(): # Create a client - client = debugger_v2.Controller2Client() + client = debugger_v2.Controller2AsyncClient() # Initialize request argument(s) request = debugger_v2.ListActiveBreakpointsRequest( @@ -353,7 +353,7 @@ def sample_list_active_breakpoints(): ) # Make the request - response = client.list_active_breakpoints(request=request) + response = await client.list_active_breakpoints(request=request) # Handle the response print(response) @@ -413,6 +413,14 @@ def sample_list_active_breakpoints(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = await rpc( request, @@ -448,9 +456,9 @@ async def update_active_breakpoint( from google.cloud import debugger_v2 - def sample_update_active_breakpoint(): + async def sample_update_active_breakpoint(): # Create a client - client = debugger_v2.Controller2Client() + client = debugger_v2.Controller2AsyncClient() # Initialize request argument(s) request = debugger_v2.UpdateActiveBreakpointRequest( @@ -458,7 +466,7 @@ def sample_update_active_breakpoint(): ) # Make the request - response = client.update_active_breakpoint(request=request) + response = await client.update_active_breakpoint(request=request) # Handle the response print(response) @@ -532,6 +540,17 @@ def sample_update_active_breakpoint(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint.id", request.breakpoint_.id), + ) + ), + ) + # Send the request. response = await rpc( request, diff --git a/google/cloud/debugger_v2/services/controller2/client.py b/google/cloud/debugger_v2/services/controller2/client.py index 88d5595..06787c5 100644 --- a/google/cloud/debugger_v2/services/controller2/client.py +++ b/google/cloud/debugger_v2/services/controller2/client.py @@ -609,6 +609,14 @@ def sample_list_active_breakpoints(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.list_active_breakpoints] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = rpc( request, @@ -718,6 +726,17 @@ def sample_update_active_breakpoint(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.update_active_breakpoint] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint.id", request.breakpoint_.id), + ) + ), + ) + # Send the request. response = rpc( request, diff --git a/google/cloud/debugger_v2/services/debugger2/async_client.py b/google/cloud/debugger_v2/services/debugger2/async_client.py index 77822c6..a1fb80f 100644 --- a/google/cloud/debugger_v2/services/debugger2/async_client.py +++ b/google/cloud/debugger_v2/services/debugger2/async_client.py @@ -224,9 +224,9 @@ async def set_breakpoint( from google.cloud import debugger_v2 - def sample_set_breakpoint(): + async def sample_set_breakpoint(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.SetBreakpointRequest( @@ -235,7 +235,7 @@ def sample_set_breakpoint(): ) # Make the request - response = client.set_breakpoint(request=request) + response = await client.set_breakpoint(request=request) # Handle the response print(response) @@ -304,6 +304,14 @@ def sample_set_breakpoint(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = await rpc( request, @@ -332,9 +340,9 @@ async def get_breakpoint( from google.cloud import debugger_v2 - def sample_get_breakpoint(): + async def sample_get_breakpoint(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.GetBreakpointRequest( @@ -344,7 +352,7 @@ def sample_get_breakpoint(): ) # Make the request - response = client.get_breakpoint(request=request) + response = await client.get_breakpoint(request=request) # Handle the response print(response) @@ -426,6 +434,17 @@ def sample_get_breakpoint(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint_id", request.breakpoint_id), + ) + ), + ) + # Send the request. response = await rpc( request, @@ -454,9 +473,9 @@ async def delete_breakpoint( from google.cloud import debugger_v2 - def sample_delete_breakpoint(): + async def sample_delete_breakpoint(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.DeleteBreakpointRequest( @@ -466,7 +485,7 @@ def sample_delete_breakpoint(): ) # Make the request - client.delete_breakpoint(request=request) + await client.delete_breakpoint(request=request) Args: request (Union[google.cloud.debugger_v2.types.DeleteBreakpointRequest, dict]): @@ -538,6 +557,17 @@ def sample_delete_breakpoint(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint_id", request.breakpoint_id), + ) + ), + ) + # Send the request. await rpc( request, @@ -562,9 +592,9 @@ async def list_breakpoints( from google.cloud import debugger_v2 - def sample_list_breakpoints(): + async def sample_list_breakpoints(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.ListBreakpointsRequest( @@ -573,7 +603,7 @@ def sample_list_breakpoints(): ) # Make the request - response = client.list_breakpoints(request=request) + response = await client.list_breakpoints(request=request) # Handle the response print(response) @@ -643,6 +673,14 @@ def sample_list_breakpoints(): client_info=DEFAULT_CLIENT_INFO, ) + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = await rpc( request, @@ -670,9 +708,9 @@ async def list_debuggees( from google.cloud import debugger_v2 - def sample_list_debuggees(): + async def sample_list_debuggees(): # Create a client - client = debugger_v2.Debugger2Client() + client = debugger_v2.Debugger2AsyncClient() # Initialize request argument(s) request = debugger_v2.ListDebuggeesRequest( @@ -681,7 +719,7 @@ def sample_list_debuggees(): ) # Make the request - response = client.list_debuggees(request=request) + response = await client.list_debuggees(request=request) # Handle the response print(response) diff --git a/google/cloud/debugger_v2/services/debugger2/client.py b/google/cloud/debugger_v2/services/debugger2/client.py index cba0b05..c847870 100644 --- a/google/cloud/debugger_v2/services/debugger2/client.py +++ b/google/cloud/debugger_v2/services/debugger2/client.py @@ -512,6 +512,14 @@ def sample_set_breakpoint(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.set_breakpoint] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = rpc( request, @@ -624,6 +632,17 @@ def sample_get_breakpoint(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.get_breakpoint] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint_id", request.breakpoint_id), + ) + ), + ) + # Send the request. response = rpc( request, @@ -726,6 +745,17 @@ def sample_delete_breakpoint(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.delete_breakpoint] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + ( + ("debuggee_id", request.debuggee_id), + ("breakpoint_id", request.breakpoint_id), + ) + ), + ) + # Send the request. rpc( request, @@ -821,6 +851,14 @@ def sample_list_breakpoints(): # and friendly error handling. rpc = self._transport._wrapped_methods[self._transport.list_breakpoints] + # Certain fields should be provided within the metadata header; + # add these here. + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata( + (("debuggee_id", request.debuggee_id),) + ), + ) + # Send the request. response = rpc( request, diff --git a/owlbot.py b/owlbot.py index 22cc59f..ac60721 100644 --- a/owlbot.py +++ b/owlbot.py @@ -51,6 +51,15 @@ "google.cloud.source_context_v1.types.source_context_pb2" ) + s.replace( + [ + library / f"google/cloud/debugger_{library.name}/services/**/*client.py", + library / f"tests/unit/gapic/debugger_{library.name}/test_controller2.py", + ], + "request\.breakpoint\.", + "request.breakpoint_." + ) + s.move(library, excludes=["setup.py", "README.rst", "docs/index.rst"]) s.remove_staging_dirs() diff --git a/tests/unit/gapic/debugger_v2/test_controller2.py b/tests/unit/gapic/debugger_v2/test_controller2.py index 6ead507..c80ac38 100644 --- a/tests/unit/gapic/debugger_v2/test_controller2.py +++ b/tests/unit/gapic/debugger_v2/test_controller2.py @@ -903,6 +903,71 @@ async def test_list_active_breakpoints_async_from_dict(): await test_list_active_breakpoints_async(request_type=dict) +def test_list_active_breakpoints_field_headers(): + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = controller.ListActiveBreakpointsRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_active_breakpoints), "__call__" + ) as call: + call.return_value = controller.ListActiveBreakpointsResponse() + client.list_active_breakpoints(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_active_breakpoints_field_headers_async(): + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = controller.ListActiveBreakpointsRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.list_active_breakpoints), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + controller.ListActiveBreakpointsResponse() + ) + await client.list_active_breakpoints(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + def test_list_active_breakpoints_flattened(): client = Controller2Client( credentials=ga_credentials.AnonymousCredentials(), @@ -1079,6 +1144,73 @@ async def test_update_active_breakpoint_async_from_dict(): await test_update_active_breakpoint_async(request_type=dict) +def test_update_active_breakpoint_field_headers(): + client = Controller2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = controller.UpdateActiveBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_.id = "id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_active_breakpoint), "__call__" + ) as call: + call.return_value = controller.UpdateActiveBreakpointResponse() + client.update_active_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint.id=id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_update_active_breakpoint_field_headers_async(): + client = Controller2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = controller.UpdateActiveBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_.id = "id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.update_active_breakpoint), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + controller.UpdateActiveBreakpointResponse() + ) + await client.update_active_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint.id=id_value", + ) in kw["metadata"] + + def test_update_active_breakpoint_flattened(): client = Controller2Client( credentials=ga_credentials.AnonymousCredentials(), diff --git a/tests/unit/gapic/debugger_v2/test_debugger2.py b/tests/unit/gapic/debugger_v2/test_debugger2.py index fab5ff2..4d17875 100644 --- a/tests/unit/gapic/debugger_v2/test_debugger2.py +++ b/tests/unit/gapic/debugger_v2/test_debugger2.py @@ -706,6 +706,67 @@ async def test_set_breakpoint_async_from_dict(): await test_set_breakpoint_async(request_type=dict) +def test_set_breakpoint_field_headers(): + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.SetBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_breakpoint), "__call__") as call: + call.return_value = debugger.SetBreakpointResponse() + client.set_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_set_breakpoint_field_headers_async(): + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.SetBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.set_breakpoint), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + debugger.SetBreakpointResponse() + ) + await client.set_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + def test_set_breakpoint_flattened(): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), @@ -891,6 +952,69 @@ async def test_get_breakpoint_async_from_dict(): await test_get_breakpoint_async(request_type=dict) +def test_get_breakpoint_field_headers(): + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.GetBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_id = "breakpoint_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_breakpoint), "__call__") as call: + call.return_value = debugger.GetBreakpointResponse() + client.get_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint_id=breakpoint_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_get_breakpoint_field_headers_async(): + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.GetBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_id = "breakpoint_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.get_breakpoint), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + debugger.GetBreakpointResponse() + ) + await client.get_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint_id=breakpoint_id_value", + ) in kw["metadata"] + + def test_get_breakpoint_flattened(): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), @@ -1080,6 +1204,71 @@ async def test_delete_breakpoint_async_from_dict(): await test_delete_breakpoint_async(request_type=dict) +def test_delete_breakpoint_field_headers(): + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.DeleteBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_id = "breakpoint_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_breakpoint), "__call__" + ) as call: + call.return_value = None + client.delete_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint_id=breakpoint_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_delete_breakpoint_field_headers_async(): + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.DeleteBreakpointRequest() + + request.debuggee_id = "debuggee_id_value" + request.breakpoint_id = "breakpoint_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_breakpoint), "__call__" + ) as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_breakpoint(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value&breakpoint_id=breakpoint_id_value", + ) in kw["metadata"] + + def test_delete_breakpoint_flattened(): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), @@ -1273,6 +1462,67 @@ async def test_list_breakpoints_async_from_dict(): await test_list_breakpoints_async(request_type=dict) +def test_list_breakpoints_field_headers(): + client = Debugger2Client( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.ListBreakpointsRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_breakpoints), "__call__") as call: + call.return_value = debugger.ListBreakpointsResponse() + client.list_breakpoints(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + +@pytest.mark.asyncio +async def test_list_breakpoints_field_headers_async(): + client = Debugger2AsyncClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Any value that is part of the HTTP/1.1 URI should be sent as + # a field header. Set these to a non-empty value. + request = debugger.ListBreakpointsRequest() + + request.debuggee_id = "debuggee_id_value" + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.list_breakpoints), "__call__") as call: + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall( + debugger.ListBreakpointsResponse() + ) + await client.list_breakpoints(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + assert args[0] == request + + # Establish that the field header was sent. + _, _, kw = call.mock_calls[0] + assert ( + "x-goog-request-params", + "debuggee_id=debuggee_id_value", + ) in kw["metadata"] + + def test_list_breakpoints_flattened(): client = Debugger2Client( credentials=ga_credentials.AnonymousCredentials(), From 9b008f134313f85a2d14ebd3f5a18e750dc816fa Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Thu, 5 May 2022 11:47:03 -0400 Subject: [PATCH 13/19] chore: [autoapprove] update readme_gen.py to include autoescape True (#96) Source-Link: https://github.com/googleapis/synthtool/commit/6b4d5a6407d740beb4158b302194a62a4108a8a6 Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:f792ee1320e03eda2d13a5281a2989f7ed8a9e50b73ef6da97fac7e1e850b149 Co-authored-by: Owl Bot --- .github/.OwlBot.lock.yaml | 4 ++-- scripts/readme-gen/readme_gen.py | 5 ++++- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index 64f82d6..b631901 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,5 +13,5 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:bc5eed3804aec2f05fad42aacf973821d9500c174015341f721a984a0825b6fd -# created: 2022-04-21T15:43:16.246106921Z + digest: sha256:f792ee1320e03eda2d13a5281a2989f7ed8a9e50b73ef6da97fac7e1e850b149 +# created: 2022-05-05T15:17:27.599381182Z diff --git a/scripts/readme-gen/readme_gen.py b/scripts/readme-gen/readme_gen.py index d309d6e..91b5967 100644 --- a/scripts/readme-gen/readme_gen.py +++ b/scripts/readme-gen/readme_gen.py @@ -28,7 +28,10 @@ jinja_env = jinja2.Environment( trim_blocks=True, loader=jinja2.FileSystemLoader( - os.path.abspath(os.path.join(os.path.dirname(__file__), 'templates')))) + os.path.abspath(os.path.join(os.path.dirname(__file__), "templates")) + ), + autoescape=True, +) README_TMPL = jinja_env.get_template('README.tmpl.rst') From 766b370b5a27d7680bd58e2cce5f3edcf467fe7d Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Thu, 5 May 2022 23:28:17 +0000 Subject: [PATCH 14/19] chore(python): auto approve template changes (#98) Source-Link: https://github.com/googleapis/synthtool/commit/453a5d9c9a55d1969240a37d36cec626d20a9024 Post-Processor: gcr.io/cloud-devrel-public-resources/owlbot-python:latest@sha256:81ed5ecdfc7cac5b699ba4537376f3563f6f04122c4ec9e735d3b3dc1d43dd32 --- .github/.OwlBot.lock.yaml | 4 ++-- .github/auto-approve.yml | 3 +++ 2 files changed, 5 insertions(+), 2 deletions(-) create mode 100644 .github/auto-approve.yml diff --git a/.github/.OwlBot.lock.yaml b/.github/.OwlBot.lock.yaml index b631901..757c9dc 100644 --- a/.github/.OwlBot.lock.yaml +++ b/.github/.OwlBot.lock.yaml @@ -13,5 +13,5 @@ # limitations under the License. docker: image: gcr.io/cloud-devrel-public-resources/owlbot-python:latest - digest: sha256:f792ee1320e03eda2d13a5281a2989f7ed8a9e50b73ef6da97fac7e1e850b149 -# created: 2022-05-05T15:17:27.599381182Z + digest: sha256:81ed5ecdfc7cac5b699ba4537376f3563f6f04122c4ec9e735d3b3dc1d43dd32 +# created: 2022-05-05T22:08:23.383410683Z diff --git a/.github/auto-approve.yml b/.github/auto-approve.yml new file mode 100644 index 0000000..311ebbb --- /dev/null +++ b/.github/auto-approve.yml @@ -0,0 +1,3 @@ +# https://github.com/googleapis/repo-automation-bots/tree/main/packages/auto-approve +processes: + - "OwlBotTemplateChanges" From 75ea50ce22b387c339c6058af918eb7a25fb3340 Mon Sep 17 00:00:00 2001 From: "gcf-owl-bot[bot]" <78513119+gcf-owl-bot[bot]@users.noreply.github.com> Date: Mon, 30 May 2022 17:48:34 +0000 Subject: [PATCH 15/19] chore: use gapic-generator-python 1.0.0 (#99) - [ ] Regenerate this pull request now. PiperOrigin-RevId: 451250442 Source-Link: https://github.com/googleapis/googleapis/commit/cca5e8181f6442b134e8d4d206fbe9e0e74684ba Source-Link: https://github.com/googleapis/googleapis-gen/commit/0b219da161a8bdcc3c6f7b2efcd82105182a30ca Copy-Tag: eyJwIjoiLmdpdGh1Yi8uT3dsQm90LnlhbWwiLCJoIjoiMGIyMTlkYTE2MWE4YmRjYzNjNmY3YjJlZmNkODIxMDUxODJhMzBjYSJ9 --- tests/unit/gapic/debugger_v2/test_controller2.py | 8 +++++++- tests/unit/gapic/debugger_v2/test_debugger2.py | 8 +++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/tests/unit/gapic/debugger_v2/test_controller2.py b/tests/unit/gapic/debugger_v2/test_controller2.py index c80ac38..769d972 100644 --- a/tests/unit/gapic/debugger_v2/test_controller2.py +++ b/tests/unit/gapic/debugger_v2/test_controller2.py @@ -14,7 +14,13 @@ # limitations under the License. # import os -import mock + +# try/except added for compatibility with python < 3.8 +try: + from unittest import mock + from unittest.mock import AsyncMock +except ImportError: + import mock import grpc from grpc.experimental import aio diff --git a/tests/unit/gapic/debugger_v2/test_debugger2.py b/tests/unit/gapic/debugger_v2/test_debugger2.py index 4d17875..89d7f02 100644 --- a/tests/unit/gapic/debugger_v2/test_debugger2.py +++ b/tests/unit/gapic/debugger_v2/test_debugger2.py @@ -14,7 +14,13 @@ # limitations under the License. # import os -import mock + +# try/except added for compatibility with python < 3.8 +try: + from unittest import mock + from unittest.mock import AsyncMock +except ImportError: + import mock import grpc from grpc.experimental import aio From 2a37072151041db69d2c71fd31a9e5bfa5256218 Mon Sep 17 00:00:00 2001 From: Anthonios Partheniou Date: Thu, 2 Jun 2022 12:39:27 -0400 Subject: [PATCH 16/19] fix(deps): require protobuf <4.0.0dev (#100) --- setup.py | 5 +++-- testing/constraints-3.6.txt | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/setup.py b/setup.py index d7dae8a..7acded1 100644 --- a/setup.py +++ b/setup.py @@ -29,8 +29,9 @@ # Until this issue is closed # https://github.com/googleapis/google-cloud-python/issues/10566 "google-api-core[grpc] >= 1.31.5, <3.0.0dev,!=2.0.*,!=2.1.*,!=2.2.*,!=2.3.0", - "proto-plus >= 1.15.0", - "google-cloud-source-context >= 1.0.0", + "proto-plus >= 1.15.0, <2.0.0dev", + "protobuf >= 3.19.0, <4.0.0dev", + "google-cloud-source-context >= 1.0.0, <2.0.0dev", ] package_root = os.path.abspath(os.path.dirname(__file__)) diff --git a/testing/constraints-3.6.txt b/testing/constraints-3.6.txt index 28f0c99..0f4f159 100644 --- a/testing/constraints-3.6.txt +++ b/testing/constraints-3.6.txt @@ -7,3 +7,4 @@ google-api-core==1.31.5 proto-plus==1.15.0 google-cloud-source-context==1.0.0 +protobuf==3.19.0 From 835df83d50beeb0ab452264f2ebb7cc8657b8c0a Mon Sep 17 00:00:00 2001 From: Dan Lee <71398022+dandhlee@users.noreply.github.com> Date: Thu, 2 Jun 2022 20:48:55 -0400 Subject: [PATCH 17/19] docs: fix changelog header to consistent size (#101) Co-authored-by: Anthonios Partheniou --- CHANGELOG.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ba309f6..ea5c430 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,6 @@ # Changelog -### [1.3.1](https://github.com/googleapis/python-debugger-client/compare/v1.3.0...v1.3.1) (2022-03-05) +## [1.3.1](https://github.com/googleapis/python-debugger-client/compare/v1.3.0...v1.3.1) (2022-03-05) ### Bug Fixes @@ -19,7 +19,7 @@ * resolve DuplicateCredentialArgs error when using credentials_file ([a4fe64d](https://github.com/googleapis/python-debugger-client/commit/a4fe64ddb07ff580ec7ba64fe02629678117a1bf)) -### [1.2.1](https://www.github.com/googleapis/python-debugger-client/compare/v1.2.0...v1.2.1) (2021-11-01) +## [1.2.1](https://www.github.com/googleapis/python-debugger-client/compare/v1.2.0...v1.2.1) (2021-11-01) ### Bug Fixes @@ -46,14 +46,14 @@ * add context manager support in client ([#38](https://www.github.com/googleapis/python-debugger-client/issues/38)) ([d8ef19f](https://www.github.com/googleapis/python-debugger-client/commit/d8ef19fdee913a1b8988fd54938bf2b8f4b11233)) -### [1.0.2](https://www.github.com/googleapis/python-debugger-client/compare/v1.0.1...v1.0.2) (2021-10-07) +## [1.0.2](https://www.github.com/googleapis/python-debugger-client/compare/v1.0.1...v1.0.2) (2021-10-07) ### Bug Fixes * **deps:** require google-cloud-source-context 1.0.0 ([#35](https://www.github.com/googleapis/python-debugger-client/issues/35)) ([1db551b](https://www.github.com/googleapis/python-debugger-client/commit/1db551b8a06f85377052f0408a59e012677f94ff)) -### [1.0.1](https://www.github.com/googleapis/python-debugger-client/compare/v1.0.0...v1.0.1) (2021-09-24) +## [1.0.1](https://www.github.com/googleapis/python-debugger-client/compare/v1.0.0...v1.0.1) (2021-09-24) ### Bug Fixes @@ -67,7 +67,7 @@ * bump release level to production/stable ([#18](https://www.github.com/googleapis/python-debugger-client/issues/18)) ([2eb231c](https://www.github.com/googleapis/python-debugger-client/commit/2eb231ca3913485e2d33d7ca1c5aa0a7c69c6872)) -### [0.1.3](https://www.github.com/googleapis/python-debugger-client/compare/v0.1.2...v0.1.3) (2021-07-29) +## [0.1.3](https://www.github.com/googleapis/python-debugger-client/compare/v0.1.2...v0.1.3) (2021-07-29) ### Bug Fixes @@ -84,14 +84,14 @@ * release as 0.1.3 ([#15](https://www.github.com/googleapis/python-debugger-client/issues/15)) ([bdc4b8f](https://www.github.com/googleapis/python-debugger-client/commit/bdc4b8f52863c4993dcc8648e0fa50ba1654e3ff)) -### [0.1.2](https://www.github.com/googleapis/python-debugger-client/compare/v0.1.1...v0.1.2) (2021-07-21) +## [0.1.2](https://www.github.com/googleapis/python-debugger-client/compare/v0.1.1...v0.1.2) (2021-07-21) ### Bug Fixes * **deps:** pin 'google-{api,cloud}-core', 'google-auth' to allow 2.x versions ([#9](https://www.github.com/googleapis/python-debugger-client/issues/9)) ([e465487](https://www.github.com/googleapis/python-debugger-client/commit/e465487f8c682efdacaf977085d3143af2d146da)) -### [0.1.1](https://www.github.com/googleapis/python-debugger-client/compare/v0.1.0...v0.1.1) (2021-07-14) +## [0.1.1](https://www.github.com/googleapis/python-debugger-client/compare/v0.1.0...v0.1.1) (2021-07-14) ### Bug Fixes From f163b9cefef769acedbbce543b02e1ed2b80903c Mon Sep 17 00:00:00 2001 From: Anthonios Partheniou Date: Fri, 3 Jun 2022 12:51:41 -0400 Subject: [PATCH 18/19] chore: test minimum dependencies in python 3.7 (#104) --- testing/constraints-3.7.txt | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/testing/constraints-3.7.txt b/testing/constraints-3.7.txt index e69de29..0f4f159 100644 --- a/testing/constraints-3.7.txt +++ b/testing/constraints-3.7.txt @@ -0,0 +1,10 @@ +# This constraints file is used to check that lower bounds +# are correct in setup.py +# List all library dependencies and extras in this file. +# Pin the version to the lower bound. +# e.g., if setup.py has "google-cloud-foo >= 1.14.0, < 2.0.0dev", +# Then this file should have google-cloud-foo==1.14.0 +google-api-core==1.31.5 +proto-plus==1.15.0 +google-cloud-source-context==1.0.0 +protobuf==3.19.0 From da79b6298eb9dd78cfd55f30e0666a4dae9078e9 Mon Sep 17 00:00:00 2001 From: "release-please[bot]" <55107282+release-please[bot]@users.noreply.github.com> Date: Tue, 7 Jun 2022 07:16:03 -0400 Subject: [PATCH 19/19] chore(main): release 1.3.2 (#102) Co-authored-by: release-please[bot] <55107282+release-please[bot]@users.noreply.github.com> Co-authored-by: Anthonios Partheniou --- CHANGELOG.md | 12 ++++++++++++ setup.py | 2 +- 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index ea5c430..ec18a7d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,17 @@ # Changelog +## [1.3.2](https://github.com/googleapis/python-debugger-client/compare/v1.3.1...v1.3.2) (2022-06-03) + + +### Bug Fixes + +* **deps:** require protobuf <4.0.0dev ([#100](https://github.com/googleapis/python-debugger-client/issues/100)) ([2a37072](https://github.com/googleapis/python-debugger-client/commit/2a37072151041db69d2c71fd31a9e5bfa5256218)) + + +### Documentation + +* fix changelog header to consistent size ([#101](https://github.com/googleapis/python-debugger-client/issues/101)) ([835df83](https://github.com/googleapis/python-debugger-client/commit/835df83d50beeb0ab452264f2ebb7cc8657b8c0a)) + ## [1.3.1](https://github.com/googleapis/python-debugger-client/compare/v1.3.0...v1.3.1) (2022-03-05) diff --git a/setup.py b/setup.py index 7acded1..34b7e05 100644 --- a/setup.py +++ b/setup.py @@ -21,7 +21,7 @@ name = "google-cloud-debugger-client" description = "Cloud Debugger API client library" -version = "1.3.1" +version = "1.3.2" release_status = "Development Status :: 5 - Production/Stable" url = "https://github.com/googleapis/python-debugger-client" dependencies = [