google-maps-routeoptimization 0.1.6__tar.gz → 0.1.7__tar.gz

{google_maps_routeoptimization-0.1.6/google_maps_routeoptimization.egg-info → google_maps_routeoptimization-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-maps-routeoptimization
-Version: 0.1.6
+Version: 0.1.7
 Summary: Google Maps Routeoptimization API client library
 Home-page: https://github.com/googleapis/google-cloud-python/tree/main/packages/google-maps-routeoptimization
 Author: Google LLC

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7}/google/maps/routeoptimization/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "0.1.6"  # {x-release-please-version}
+__version__ = "0.1.7"  # {x-release-please-version}

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7}/google/maps/routeoptimization_v1/gapic_version.py

@@ -13,4 +13,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-__version__ = "0.1.6"  # {x-release-please-version}
+__version__ = "0.1.7"  # {x-release-please-version}

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7}/google/maps/routeoptimization_v1/services/route_optimization/async_client.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 #
 from collections import OrderedDict
+import logging as std_logging
 import re
 from typing import (
     Callable,
@@ -52,6 +53,15 @@ from .client import RouteOptimizationClient
 from .transports.base import DEFAULT_CLIENT_INFO, RouteOptimizationTransport
 from .transports.grpc_asyncio import RouteOptimizationGrpcAsyncIOTransport
 
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
 
 class RouteOptimizationAsyncClient:
     """A service for optimizing vehicle tours.
@@ -282,6 +292,28 @@ class RouteOptimizationAsyncClient:
             client_info=client_info,
         )
 
+        if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+            std_logging.DEBUG
+        ):  # pragma: NO COVER
+            _LOGGER.debug(
+                "Created client `google.maps.routeoptimization_v1.RouteOptimizationAsyncClient`.",
+                extra={
+                    "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                    "universeDomain": getattr(
+                        self._client._transport._credentials, "universe_domain", ""
+                    ),
+                    "credentialsType": f"{type(self._client._transport._credentials).__module__}.{type(self._client._transport._credentials).__qualname__}",
+                    "credentialsInfo": getattr(
+                        self.transport._credentials, "get_cred_info", lambda: None
+                    )(),
+                }
+                if hasattr(self._client._transport, "_credentials")
+                else {
+                    "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                    "credentialsType": None,
+                },
+            )
+
     async def optimize_tours(
         self,
         request: Optional[
@@ -290,7 +322,7 @@ class RouteOptimizationAsyncClient:
         *,
         retry: OptionalRetry = gapic_v1.method.DEFAULT,
         timeout: Union[float, object] = gapic_v1.method.DEFAULT,
-        metadata: Sequence[Tuple[str, str]] = (),
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
     ) -> route_optimization_service.OptimizeToursResponse:
         r"""Sends an ``OptimizeToursRequest`` containing a ``ShipmentModel``
         and returns an ``OptimizeToursResponse`` containing
@@ -344,8 +376,10 @@ class RouteOptimizationAsyncClient:
             retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,
                 should be retried.
             timeout (float): The timeout for this request.
-            metadata (Sequence[Tuple[str, str]]): Strings which should be
-                sent along with the request as metadata.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
 
         Returns:
             google.maps.routeoptimization_v1.types.OptimizeToursResponse:
@@ -396,7 +430,7 @@ class RouteOptimizationAsyncClient:
         *,
         retry: OptionalRetry = gapic_v1.method.DEFAULT,
         timeout: Union[float, object] = gapic_v1.method.DEFAULT,
-        metadata: Sequence[Tuple[str, str]] = (),
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
     ) -> operation_async.AsyncOperation:
         r"""Optimizes vehicle tours for one or more ``OptimizeToursRequest``
         messages as a batch.
@@ -473,8 +507,10 @@ class RouteOptimizationAsyncClient:
             retry (google.api_core.retry_async.AsyncRetry): Designation of what errors, if any,
                 should be retried.
             timeout (float): The timeout for this request.
-            metadata (Sequence[Tuple[str, str]]): Strings which should be
-                sent along with the request as metadata.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
 
         Returns:
             google.api_core.operation_async.AsyncOperation:
@@ -533,7 +569,7 @@ class RouteOptimizationAsyncClient:
         *,
         retry: OptionalRetry = gapic_v1.method.DEFAULT,
         timeout: Union[float, object] = gapic_v1.method.DEFAULT,
-        metadata: Sequence[Tuple[str, str]] = (),
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
     ) -> operations_pb2.Operation:
         r"""Gets the latest state of a long-running operation.
 
@@ -544,8 +580,10 @@ class RouteOptimizationAsyncClient:
             retry (google.api_core.retry_async.AsyncRetry): Designation of what errors,
                     if any, should be retried.
             timeout (float): The timeout for this request.
-            metadata (Sequence[Tuple[str, str]]): Strings which should be
-                sent along with the request as metadata.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
         Returns:
             ~.operations_pb2.Operation:
                 An ``Operation`` object.

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7}/google/maps/routeoptimization_v1/services/route_optimization/client.py

@@ -14,6 +14,7 @@
 # limitations under the License.
 #
 from collections import OrderedDict
+import logging as std_logging
 import os
 import re
 from typing import (
@@ -48,6 +49,15 @@ try:
 except AttributeError:  # pragma: NO COVER
     OptionalRetry = Union[retries.Retry, object, None]  # type: ignore
 
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
 from google.api_core import operation  # type: ignore
 from google.api_core import operation_async  # type: ignore
 from google.longrunning import operations_pb2  # type: ignore
@@ -586,6 +596,10 @@ class RouteOptimizationClient(metaclass=RouteOptimizationClientMeta):
         # Initialize the universe domain validation.
         self._is_universe_domain_valid = False
 
+        if CLIENT_LOGGING_SUPPORTED:  # pragma: NO COVER
+            # Setup logging.
+            client_logging.initialize_logging()
+
         api_key_value = getattr(self._client_options, "api_key", None)
         if api_key_value and credentials:
             raise ValueError(
@@ -652,6 +666,29 @@ class RouteOptimizationClient(metaclass=RouteOptimizationClientMeta):
                 api_audience=self._client_options.api_audience,
             )
 
+        if "async" not in str(self._transport):
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                std_logging.DEBUG
+            ):  # pragma: NO COVER
+                _LOGGER.debug(
+                    "Created client `google.maps.routeoptimization_v1.RouteOptimizationClient`.",
+                    extra={
+                        "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                        "universeDomain": getattr(
+                            self._transport._credentials, "universe_domain", ""
+                        ),
+                        "credentialsType": f"{type(self._transport._credentials).__module__}.{type(self._transport._credentials).__qualname__}",
+                        "credentialsInfo": getattr(
+                            self.transport._credentials, "get_cred_info", lambda: None
+                        )(),
+                    }
+                    if hasattr(self._transport, "_credentials")
+                    else {
+                        "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                        "credentialsType": None,
+                    },
+                )
+
     def optimize_tours(
         self,
         request: Optional[
@@ -660,7 +697,7 @@ class RouteOptimizationClient(metaclass=RouteOptimizationClientMeta):
         *,
         retry: OptionalRetry = gapic_v1.method.DEFAULT,
         timeout: Union[float, object] = gapic_v1.method.DEFAULT,
-        metadata: Sequence[Tuple[str, str]] = (),
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
     ) -> route_optimization_service.OptimizeToursResponse:
         r"""Sends an ``OptimizeToursRequest`` containing a ``ShipmentModel``
         and returns an ``OptimizeToursResponse`` containing
@@ -714,8 +751,10 @@ class RouteOptimizationClient(metaclass=RouteOptimizationClientMeta):
             retry (google.api_core.retry.Retry): Designation of what errors, if any,
                 should be retried.
             timeout (float): The timeout for this request.
-            metadata (Sequence[Tuple[str, str]]): Strings which should be
-                sent along with the request as metadata.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
 
         Returns:
             google.maps.routeoptimization_v1.types.OptimizeToursResponse:
@@ -764,7 +803,7 @@ class RouteOptimizationClient(metaclass=RouteOptimizationClientMeta):
         *,
         retry: OptionalRetry = gapic_v1.method.DEFAULT,
         timeout: Union[float, object] = gapic_v1.method.DEFAULT,
-        metadata: Sequence[Tuple[str, str]] = (),
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
     ) -> operation.Operation:
         r"""Optimizes vehicle tours for one or more ``OptimizeToursRequest``
         messages as a batch.
@@ -841,8 +880,10 @@ class RouteOptimizationClient(metaclass=RouteOptimizationClientMeta):
             retry (google.api_core.retry.Retry): Designation of what errors, if any,
                 should be retried.
             timeout (float): The timeout for this request.
-            metadata (Sequence[Tuple[str, str]]): Strings which should be
-                sent along with the request as metadata.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
 
         Returns:
             google.api_core.operation.Operation:
@@ -912,7 +953,7 @@ class RouteOptimizationClient(metaclass=RouteOptimizationClientMeta):
         *,
         retry: OptionalRetry = gapic_v1.method.DEFAULT,
         timeout: Union[float, object] = gapic_v1.method.DEFAULT,
-        metadata: Sequence[Tuple[str, str]] = (),
+        metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
     ) -> operations_pb2.Operation:
         r"""Gets the latest state of a long-running operation.
 
@@ -923,8 +964,10 @@ class RouteOptimizationClient(metaclass=RouteOptimizationClientMeta):
             retry (google.api_core.retry.Retry): Designation of what errors,
                     if any, should be retried.
             timeout (float): The timeout for this request.
-            metadata (Sequence[Tuple[str, str]]): Strings which should be
-                sent along with the request as metadata.
+            metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                sent along with the request as metadata. Normally, each value must be of type `str`,
+                but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                be of type `bytes`.
         Returns:
             ~.operations_pb2.Operation:
                 An ``Operation`` object.

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7}/google/maps/routeoptimization_v1/services/route_optimization/transports/grpc.py

@@ -13,6 +13,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+import json
+import logging as std_logging
+import pickle
 from typing import Callable, Dict, Optional, Sequence, Tuple, Union
 import warnings
 
@@ -21,12 +24,90 @@ import google.auth  # type: ignore
 from google.auth import credentials as ga_credentials  # type: ignore
 from google.auth.transport.grpc import SslCredentials  # type: ignore
 from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf.json_format import MessageToJson
+import google.protobuf.message
 import grpc  # type: ignore
+import proto  # type: ignore
 
 from google.maps.routeoptimization_v1.types import route_optimization_service
 
 from .base import DEFAULT_CLIENT_INFO, RouteOptimizationTransport
 
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+
+class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor):  # pragma: NO COVER
+    def intercept_unary_unary(self, continuation, client_call_details, request):
+        logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+            std_logging.DEBUG
+        )
+        if logging_enabled:  # pragma: NO COVER
+            request_metadata = client_call_details.metadata
+            if isinstance(request, proto.Message):
+                request_payload = type(request).to_json(request)
+            elif isinstance(request, google.protobuf.message.Message):
+                request_payload = MessageToJson(request)
+            else:
+                request_payload = f"{type(request).__name__}: {pickle.dumps(request)}"
+
+            request_metadata = {
+                key: value.decode("utf-8") if isinstance(value, bytes) else value
+                for key, value in request_metadata
+            }
+            grpc_request = {
+                "payload": request_payload,
+                "requestMethod": "grpc",
+                "metadata": dict(request_metadata),
+            }
+            _LOGGER.debug(
+                f"Sending request for {client_call_details.method}",
+                extra={
+                    "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                    "rpcName": client_call_details.method,
+                    "request": grpc_request,
+                    "metadata": grpc_request["metadata"],
+                },
+            )
+
+        response = continuation(client_call_details, request)
+        if logging_enabled:  # pragma: NO COVER
+            response_metadata = response.trailing_metadata()
+            # Convert gRPC metadata `<class 'grpc.aio._metadata.Metadata'>` to list of tuples
+            metadata = (
+                dict([(k, str(v)) for k, v in response_metadata])
+                if response_metadata
+                else None
+            )
+            result = response.result()
+            if isinstance(result, proto.Message):
+                response_payload = type(result).to_json(result)
+            elif isinstance(result, google.protobuf.message.Message):
+                response_payload = MessageToJson(result)
+            else:
+                response_payload = f"{type(result).__name__}: {pickle.dumps(result)}"
+            grpc_response = {
+                "payload": response_payload,
+                "metadata": metadata,
+                "status": "OK",
+            }
+            _LOGGER.debug(
+                f"Received response for {client_call_details.method}.",
+                extra={
+                    "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                    "rpcName": client_call_details.method,
+                    "response": grpc_response,
+                    "metadata": grpc_response["metadata"],
+                },
+            )
+        return response
+
 
 class RouteOptimizationGrpcTransport(RouteOptimizationTransport):
     """gRPC backend transport for RouteOptimization.
@@ -203,7 +284,12 @@ class RouteOptimizationGrpcTransport(RouteOptimizationTransport):
                 ],
             )
 
-        # Wrap messages. This must be done after self._grpc_channel exists
+        self._interceptor = _LoggingClientInterceptor()
+        self._logged_channel = grpc.intercept_channel(
+            self._grpc_channel, self._interceptor
+        )
+
+        # Wrap messages. This must be done after self._logged_channel exists
         self._prep_wrapped_messages(client_info)
 
     @classmethod
@@ -267,7 +353,9 @@ class RouteOptimizationGrpcTransport(RouteOptimizationTransport):
         """
         # Quick check: Only create a new client if we do not already have one.
         if self._operations_client is None:
-            self._operations_client = operations_v1.OperationsClient(self.grpc_channel)
+            self._operations_client = operations_v1.OperationsClient(
+                self._logged_channel
+            )
 
         # Return the client from cache.
         return self._operations_client
@@ -309,7 +397,7 @@ class RouteOptimizationGrpcTransport(RouteOptimizationTransport):
         # gRPC handles serialization and deserialization, so we just need
         # to pass in the functions for each.
         if "optimize_tours" not in self._stubs:
-            self._stubs["optimize_tours"] = self.grpc_channel.unary_unary(
+            self._stubs["optimize_tours"] = self._logged_channel.unary_unary(
                 "/google.maps.routeoptimization.v1.RouteOptimization/OptimizeTours",
                 request_serializer=route_optimization_service.OptimizeToursRequest.serialize,
                 response_deserializer=route_optimization_service.OptimizeToursResponse.deserialize,
@@ -361,7 +449,7 @@ class RouteOptimizationGrpcTransport(RouteOptimizationTransport):
         # gRPC handles serialization and deserialization, so we just need
         # to pass in the functions for each.
         if "batch_optimize_tours" not in self._stubs:
-            self._stubs["batch_optimize_tours"] = self.grpc_channel.unary_unary(
+            self._stubs["batch_optimize_tours"] = self._logged_channel.unary_unary(
                 "/google.maps.routeoptimization.v1.RouteOptimization/BatchOptimizeTours",
                 request_serializer=route_optimization_service.BatchOptimizeToursRequest.serialize,
                 response_deserializer=operations_pb2.Operation.FromString,
@@ -369,7 +457,7 @@ class RouteOptimizationGrpcTransport(RouteOptimizationTransport):
         return self._stubs["batch_optimize_tours"]
 
     def close(self):
-        self.grpc_channel.close()
+        self._logged_channel.close()
 
     @property
     def get_operation(
@@ -381,7 +469,7 @@ class RouteOptimizationGrpcTransport(RouteOptimizationTransport):
         # gRPC handles serialization and deserialization, so we just need
         # to pass in the functions for each.
         if "get_operation" not in self._stubs:
-            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+            self._stubs["get_operation"] = self._logged_channel.unary_unary(
                 "/google.longrunning.Operations/GetOperation",
                 request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
                 response_deserializer=operations_pb2.Operation.FromString,

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7}/google/maps/routeoptimization_v1/services/route_optimization/transports/grpc_asyncio.py

@@ -14,6 +14,9 @@
 # limitations under the License.
 #
 import inspect
+import json
+import logging as std_logging
+import pickle
 from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
 import warnings
 
@@ -23,14 +26,93 @@ from google.api_core import retry_async as retries
 from google.auth import credentials as ga_credentials  # type: ignore
 from google.auth.transport.grpc import SslCredentials  # type: ignore
 from google.longrunning import operations_pb2  # type: ignore
+from google.protobuf.json_format import MessageToJson
+import google.protobuf.message
 import grpc  # type: ignore
 from grpc.experimental import aio  # type: ignore
+import proto  # type: ignore
 
 from google.maps.routeoptimization_v1.types import route_optimization_service
 
 from .base import DEFAULT_CLIENT_INFO, RouteOptimizationTransport
 from .grpc import RouteOptimizationGrpcTransport
 
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = std_logging.getLogger(__name__)
+
+
+class _LoggingClientAIOInterceptor(
+    grpc.aio.UnaryUnaryClientInterceptor
+):  # pragma: NO COVER
+    async def intercept_unary_unary(self, continuation, client_call_details, request):
+        logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+            std_logging.DEBUG
+        )
+        if logging_enabled:  # pragma: NO COVER
+            request_metadata = client_call_details.metadata
+            if isinstance(request, proto.Message):
+                request_payload = type(request).to_json(request)
+            elif isinstance(request, google.protobuf.message.Message):
+                request_payload = MessageToJson(request)
+            else:
+                request_payload = f"{type(request).__name__}: {pickle.dumps(request)}"
+
+            request_metadata = {
+                key: value.decode("utf-8") if isinstance(value, bytes) else value
+                for key, value in request_metadata
+            }
+            grpc_request = {
+                "payload": request_payload,
+                "requestMethod": "grpc",
+                "metadata": dict(request_metadata),
+            }
+            _LOGGER.debug(
+                f"Sending request for {client_call_details.method}",
+                extra={
+                    "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                    "rpcName": str(client_call_details.method),
+                    "request": grpc_request,
+                    "metadata": grpc_request["metadata"],
+                },
+            )
+        response = await continuation(client_call_details, request)
+        if logging_enabled:  # pragma: NO COVER
+            response_metadata = await response.trailing_metadata()
+            # Convert gRPC metadata `<class 'grpc.aio._metadata.Metadata'>` to list of tuples
+            metadata = (
+                dict([(k, str(v)) for k, v in response_metadata])
+                if response_metadata
+                else None
+            )
+            result = await response
+            if isinstance(result, proto.Message):
+                response_payload = type(result).to_json(result)
+            elif isinstance(result, google.protobuf.message.Message):
+                response_payload = MessageToJson(result)
+            else:
+                response_payload = f"{type(result).__name__}: {pickle.dumps(result)}"
+            grpc_response = {
+                "payload": response_payload,
+                "metadata": metadata,
+                "status": "OK",
+            }
+            _LOGGER.debug(
+                f"Received response to rpc {client_call_details.method}.",
+                extra={
+                    "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                    "rpcName": str(client_call_details.method),
+                    "response": grpc_response,
+                    "metadata": grpc_response["metadata"],
+                },
+            )
+        return response
+
 
 class RouteOptimizationGrpcAsyncIOTransport(RouteOptimizationTransport):
     """gRPC AsyncIO backend transport for RouteOptimization.
@@ -250,10 +332,13 @@ class RouteOptimizationGrpcAsyncIOTransport(RouteOptimizationTransport):
                 ],
             )
 
-        # Wrap messages. This must be done after self._grpc_channel exists
+        self._interceptor = _LoggingClientAIOInterceptor()
+        self._grpc_channel._unary_unary_interceptors.append(self._interceptor)
+        self._logged_channel = self._grpc_channel
         self._wrap_with_kind = (
             "kind" in inspect.signature(gapic_v1.method_async.wrap_method).parameters
         )
+        # Wrap messages. This must be done after self._logged_channel exists
         self._prep_wrapped_messages(client_info)
 
     @property
@@ -276,7 +361,7 @@ class RouteOptimizationGrpcAsyncIOTransport(RouteOptimizationTransport):
         # Quick check: Only create a new client if we do not already have one.
         if self._operations_client is None:
             self._operations_client = operations_v1.OperationsAsyncClient(
-                self.grpc_channel
+                self._logged_channel
             )
 
         # Return the client from cache.
@@ -319,7 +404,7 @@ class RouteOptimizationGrpcAsyncIOTransport(RouteOptimizationTransport):
         # gRPC handles serialization and deserialization, so we just need
         # to pass in the functions for each.
         if "optimize_tours" not in self._stubs:
-            self._stubs["optimize_tours"] = self.grpc_channel.unary_unary(
+            self._stubs["optimize_tours"] = self._logged_channel.unary_unary(
                 "/google.maps.routeoptimization.v1.RouteOptimization/OptimizeTours",
                 request_serializer=route_optimization_service.OptimizeToursRequest.serialize,
                 response_deserializer=route_optimization_service.OptimizeToursResponse.deserialize,
@@ -372,7 +457,7 @@ class RouteOptimizationGrpcAsyncIOTransport(RouteOptimizationTransport):
         # gRPC handles serialization and deserialization, so we just need
         # to pass in the functions for each.
         if "batch_optimize_tours" not in self._stubs:
-            self._stubs["batch_optimize_tours"] = self.grpc_channel.unary_unary(
+            self._stubs["batch_optimize_tours"] = self._logged_channel.unary_unary(
                 "/google.maps.routeoptimization.v1.RouteOptimization/BatchOptimizeTours",
                 request_serializer=route_optimization_service.BatchOptimizeToursRequest.serialize,
                 response_deserializer=operations_pb2.Operation.FromString,
@@ -414,7 +499,7 @@ class RouteOptimizationGrpcAsyncIOTransport(RouteOptimizationTransport):
         return gapic_v1.method_async.wrap_method(func, *args, **kwargs)
 
     def close(self):
-        return self.grpc_channel.close()
+        return self._logged_channel.close()
 
     @property
     def kind(self) -> str:
@@ -430,7 +515,7 @@ class RouteOptimizationGrpcAsyncIOTransport(RouteOptimizationTransport):
         # gRPC handles serialization and deserialization, so we just need
         # to pass in the functions for each.
         if "get_operation" not in self._stubs:
-            self._stubs["get_operation"] = self.grpc_channel.unary_unary(
+            self._stubs["get_operation"] = self._logged_channel.unary_unary(
                 "/google.longrunning.Operations/GetOperation",
                 request_serializer=operations_pb2.GetOperationRequest.SerializeToString,
                 response_deserializer=operations_pb2.Operation.FromString,

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7}/google/maps/routeoptimization_v1/services/route_optimization/transports/rest.py

@@ -13,9 +13,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
 import dataclasses
 import json  # type: ignore
+import logging
 from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union
 import warnings
 
@@ -38,6 +38,14 @@ try:
 except AttributeError:  # pragma: NO COVER
     OptionalRetry = Union[retries.Retry, object, None]  # type: ignore
 
+try:
+    from google.api_core import client_logging  # type: ignore
+
+    CLIENT_LOGGING_SUPPORTED = True  # pragma: NO COVER
+except ImportError:  # pragma: NO COVER
+    CLIENT_LOGGING_SUPPORTED = False
+
+_LOGGER = logging.getLogger(__name__)
 
 DEFAULT_CLIENT_INFO = gapic_v1.client_info.ClientInfo(
     gapic_version=BASE_DEFAULT_CLIENT_INFO.gapic_version,
@@ -86,9 +94,10 @@ class RouteOptimizationRestInterceptor:
     def pre_batch_optimize_tours(
         self,
         request: route_optimization_service.BatchOptimizeToursRequest,
-        metadata: Sequence[Tuple[str, str]],
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
     ) -> Tuple[
-        route_optimization_service.BatchOptimizeToursRequest, Sequence[Tuple[str, str]]
+        route_optimization_service.BatchOptimizeToursRequest,
+        Sequence[Tuple[str, Union[str, bytes]]],
     ]:
         """Pre-rpc interceptor for batch_optimize_tours
 
@@ -111,9 +120,10 @@ class RouteOptimizationRestInterceptor:
     def pre_optimize_tours(
         self,
         request: route_optimization_service.OptimizeToursRequest,
-        metadata: Sequence[Tuple[str, str]],
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
     ) -> Tuple[
-        route_optimization_service.OptimizeToursRequest, Sequence[Tuple[str, str]]
+        route_optimization_service.OptimizeToursRequest,
+        Sequence[Tuple[str, Union[str, bytes]]],
     ]:
         """Pre-rpc interceptor for optimize_tours
 
@@ -136,8 +146,10 @@ class RouteOptimizationRestInterceptor:
     def pre_get_operation(
         self,
         request: operations_pb2.GetOperationRequest,
-        metadata: Sequence[Tuple[str, str]],
-    ) -> Tuple[operations_pb2.GetOperationRequest, Sequence[Tuple[str, str]]]:
+        metadata: Sequence[Tuple[str, Union[str, bytes]]],
+    ) -> Tuple[
+        operations_pb2.GetOperationRequest, Sequence[Tuple[str, Union[str, bytes]]]
+    ]:
         """Pre-rpc interceptor for get_operation
 
         Override in a subclass to manipulate the request or metadata
@@ -336,7 +348,7 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             *,
             retry: OptionalRetry = gapic_v1.method.DEFAULT,
             timeout: Optional[float] = None,
-            metadata: Sequence[Tuple[str, str]] = (),
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
         ) -> operations_pb2.Operation:
             r"""Call the batch optimize tours method over HTTP.
 
@@ -352,8 +364,10 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
                 retry (google.api_core.retry.Retry): Designation of what errors, if any,
                     should be retried.
                 timeout (float): The timeout for this request.
-                metadata (Sequence[Tuple[str, str]]): Strings which should be
-                    sent along with the request as metadata.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
 
             Returns:
                 ~.operations_pb2.Operation:
@@ -366,6 +380,7 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             http_options = (
                 _BaseRouteOptimizationRestTransport._BaseBatchOptimizeTours._get_http_options()
             )
+
             request, metadata = self._interceptor.pre_batch_optimize_tours(
                 request, metadata
             )
@@ -382,6 +397,33 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
                 transcoded_request
             )
 
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = json_format.MessageToJson(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.maps.routeoptimization_v1.RouteOptimizationClient.BatchOptimizeTours",
+                    extra={
+                        "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                        "rpcName": "BatchOptimizeTours",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
             # Send the request
             response = RouteOptimizationRestTransport._BatchOptimizeTours._get_response(
                 self._host,
@@ -401,7 +443,29 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             # Return the response
             resp = operations_pb2.Operation()
             json_format.Parse(response.content, resp, ignore_unknown_fields=True)
+
             resp = self._interceptor.post_batch_optimize_tours(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = json_format.MessageToJson(resp)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.maps.routeoptimization_v1.RouteOptimizationClient.batch_optimize_tours",
+                    extra={
+                        "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                        "rpcName": "BatchOptimizeTours",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
             return resp
 
     class _OptimizeTours(
@@ -440,7 +504,7 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             *,
             retry: OptionalRetry = gapic_v1.method.DEFAULT,
             timeout: Optional[float] = None,
-            metadata: Sequence[Tuple[str, str]] = (),
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
         ) -> route_optimization_service.OptimizeToursResponse:
             r"""Call the optimize tours method over HTTP.
 
@@ -453,8 +517,10 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
                 retry (google.api_core.retry.Retry): Designation of what errors, if any,
                     should be retried.
                 timeout (float): The timeout for this request.
-                metadata (Sequence[Tuple[str, str]]): Strings which should be
-                    sent along with the request as metadata.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
 
             Returns:
                 ~.route_optimization_service.OptimizeToursResponse:
@@ -469,6 +535,7 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             http_options = (
                 _BaseRouteOptimizationRestTransport._BaseOptimizeTours._get_http_options()
             )
+
             request, metadata = self._interceptor.pre_optimize_tours(request, metadata)
             transcoded_request = _BaseRouteOptimizationRestTransport._BaseOptimizeTours._get_transcoded_request(
                 http_options, request
@@ -483,6 +550,33 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
                 transcoded_request
             )
 
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = type(request).to_json(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.maps.routeoptimization_v1.RouteOptimizationClient.OptimizeTours",
+                    extra={
+                        "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                        "rpcName": "OptimizeTours",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
             # Send the request
             response = RouteOptimizationRestTransport._OptimizeTours._get_response(
                 self._host,
@@ -504,7 +598,33 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             pb_resp = route_optimization_service.OptimizeToursResponse.pb(resp)
 
             json_format.Parse(response.content, pb_resp, ignore_unknown_fields=True)
+
             resp = self._interceptor.post_optimize_tours(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = (
+                        route_optimization_service.OptimizeToursResponse.to_json(
+                            response
+                        )
+                    )
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.maps.routeoptimization_v1.RouteOptimizationClient.optimize_tours",
+                    extra={
+                        "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                        "rpcName": "OptimizeTours",
+                        "metadata": http_response["headers"],
+                        "httpResponse": http_response,
+                    },
+                )
             return resp
 
     @property
@@ -566,7 +686,7 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             *,
             retry: OptionalRetry = gapic_v1.method.DEFAULT,
             timeout: Optional[float] = None,
-            metadata: Sequence[Tuple[str, str]] = (),
+            metadata: Sequence[Tuple[str, Union[str, bytes]]] = (),
         ) -> operations_pb2.Operation:
             r"""Call the get operation method over HTTP.
 
@@ -576,8 +696,10 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
                 retry (google.api_core.retry.Retry): Designation of what errors, if any,
                     should be retried.
                 timeout (float): The timeout for this request.
-                metadata (Sequence[Tuple[str, str]]): Strings which should be
-                    sent along with the request as metadata.
+                metadata (Sequence[Tuple[str, Union[str, bytes]]]): Key/value pairs which should be
+                    sent along with the request as metadata. Normally, each value must be of type `str`,
+                    but for metadata keys ending with the suffix `-bin`, the corresponding values must
+                    be of type `bytes`.
 
             Returns:
                 operations_pb2.Operation: Response from GetOperation method.
@@ -586,6 +708,7 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             http_options = (
                 _BaseRouteOptimizationRestTransport._BaseGetOperation._get_http_options()
             )
+
             request, metadata = self._interceptor.pre_get_operation(request, metadata)
             transcoded_request = _BaseRouteOptimizationRestTransport._BaseGetOperation._get_transcoded_request(
                 http_options, request
@@ -596,6 +719,33 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
                 transcoded_request
             )
 
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                request_url = "{host}{uri}".format(
+                    host=self._host, uri=transcoded_request["uri"]
+                )
+                method = transcoded_request["method"]
+                try:
+                    request_payload = json_format.MessageToJson(request)
+                except:
+                    request_payload = None
+                http_request = {
+                    "payload": request_payload,
+                    "requestMethod": method,
+                    "requestUrl": request_url,
+                    "headers": dict(metadata),
+                }
+                _LOGGER.debug(
+                    f"Sending request for google.maps.routeoptimization_v1.RouteOptimizationClient.GetOperation",
+                    extra={
+                        "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                        "rpcName": "GetOperation",
+                        "httpRequest": http_request,
+                        "metadata": http_request["headers"],
+                    },
+                )
+
             # Send the request
             response = RouteOptimizationRestTransport._GetOperation._get_response(
                 self._host,
@@ -615,6 +765,27 @@ class RouteOptimizationRestTransport(_BaseRouteOptimizationRestTransport):
             resp = operations_pb2.Operation()
             resp = json_format.Parse(content, resp)
             resp = self._interceptor.post_get_operation(resp)
+            if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(
+                logging.DEBUG
+            ):  # pragma: NO COVER
+                try:
+                    response_payload = json_format.MessageToJson(resp)
+                except:
+                    response_payload = None
+                http_response = {
+                    "payload": response_payload,
+                    "headers": dict(response.headers),
+                    "status": response.status_code,
+                }
+                _LOGGER.debug(
+                    "Received response for google.maps.routeoptimization_v1.RouteOptimizationAsyncClient.GetOperation",
+                    extra={
+                        "serviceName": "google.maps.routeoptimization.v1.RouteOptimization",
+                        "rpcName": "GetOperation",
+                        "httpResponse": http_response,
+                        "metadata": http_response["headers"],
+                    },
+                )
             return resp
 
     @property

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7/google_maps_routeoptimization.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: google-maps-routeoptimization
-Version: 0.1.6
+Version: 0.1.7
 Summary: Google Maps Routeoptimization API client library
 Home-page: https://github.com/googleapis/google-cloud-python/tree/main/packages/google-maps-routeoptimization
 Author: Google LLC

{google_maps_routeoptimization-0.1.6 → google_maps_routeoptimization-0.1.7}/tests/unit/gapic/routeoptimization_v1/test_route_optimization.py

@@ -1719,6 +1719,7 @@ def test_optimize_tours_rest_required_fields(
 
             response_value._content = json_return_value.encode("UTF-8")
             req.return_value = response_value
+            req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
 
             response = client.optimize_tours(request)
 
@@ -1844,6 +1845,7 @@ def test_batch_optimize_tours_rest_required_fields(
 
             response_value._content = json_return_value.encode("UTF-8")
             req.return_value = response_value
+            req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
 
             response = client.batch_optimize_tours(request)
 
@@ -2115,6 +2117,7 @@ def test_optimize_tours_rest_bad_request(
         response_value.status_code = 400
         response_value.request = mock.Mock()
         req.return_value = response_value
+        req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
         client.optimize_tours(request)
 
 
@@ -2150,6 +2153,7 @@ def test_optimize_tours_rest_call_success(request_type):
         json_return_value = json_format.MessageToJson(return_value)
         response_value.content = json_return_value.encode("UTF-8")
         req.return_value = response_value
+        req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
         response = client.optimize_tours(request)
 
     # Establish that the response is the type that we expect.
@@ -2190,6 +2194,7 @@ def test_optimize_tours_rest_interceptors(null_interceptor):
 
         req.return_value = mock.Mock()
         req.return_value.status_code = 200
+        req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
         return_value = route_optimization_service.OptimizeToursResponse.to_json(
             route_optimization_service.OptimizeToursResponse()
         )
@@ -2236,6 +2241,7 @@ def test_batch_optimize_tours_rest_bad_request(
         response_value.status_code = 400
         response_value.request = mock.Mock()
         req.return_value = response_value
+        req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
         client.batch_optimize_tours(request)
 
 
@@ -2266,6 +2272,7 @@ def test_batch_optimize_tours_rest_call_success(request_type):
         json_return_value = json_format.MessageToJson(return_value)
         response_value.content = json_return_value.encode("UTF-8")
         req.return_value = response_value
+        req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
         response = client.batch_optimize_tours(request)
 
     # Establish that the response is the type that we expect.
@@ -2307,6 +2314,7 @@ def test_batch_optimize_tours_rest_interceptors(null_interceptor):
 
         req.return_value = mock.Mock()
         req.return_value.status_code = 200
+        req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
         return_value = json_format.MessageToJson(operations_pb2.Operation())
         req.return_value.content = return_value
 
@@ -2353,6 +2361,7 @@ def test_get_operation_rest_bad_request(
         response_value.status_code = 400
         response_value.request = Request()
         req.return_value = response_value
+        req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
         client.get_operation(request)
 
 
@@ -2383,6 +2392,7 @@ def test_get_operation_rest(request_type):
         response_value.content = json_return_value.encode("UTF-8")
 
         req.return_value = response_value
+        req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"}
 
         response = client.get_operation(request)