diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery/__init__.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery/__init__.py index 52b98b75d2b5..6f2d21478c2a 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery/__init__.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery/__init__.py @@ -37,6 +37,8 @@ BatchCreateTasksResponse, CreateDeliveryVehicleRequest, CreateTaskRequest, + DeleteDeliveryVehicleRequest, + DeleteTaskRequest, GetDeliveryVehicleRequest, GetTaskRequest, GetTaskTrackingInfoRequest, @@ -72,6 +74,8 @@ "BatchCreateTasksResponse", "CreateDeliveryVehicleRequest", "CreateTaskRequest", + "DeleteDeliveryVehicleRequest", + "DeleteTaskRequest", "GetDeliveryVehicleRequest", "GetTaskRequest", "GetTaskTrackingInfoRequest", diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery/gapic_version.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery/gapic_version.py index 80a5f33e3aea..558c8aab67c5 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery/gapic_version.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "0.2.9" # {x-release-please-version} +__version__ = "0.0.0" # {x-release-please-version} diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/__init__.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/__init__.py index 425525a2bf02..5372ce030d5e 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/__init__.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/__init__.py @@ -32,6 +32,8 @@ BatchCreateTasksResponse, CreateDeliveryVehicleRequest, CreateTaskRequest, + DeleteDeliveryVehicleRequest, + DeleteTaskRequest, GetDeliveryVehicleRequest, GetTaskRequest, GetTaskTrackingInfoRequest, @@ -58,6 +60,8 @@ "BatchCreateTasksResponse", "CreateDeliveryVehicleRequest", "CreateTaskRequest", + "DeleteDeliveryVehicleRequest", + "DeleteTaskRequest", "DeliveryRequestHeader", "DeliveryServiceClient", "DeliveryVehicle", diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/gapic_metadata.json b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/gapic_metadata.json index 8b15810ecafd..186f7cd44898 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/gapic_metadata.json +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/gapic_metadata.json @@ -25,6 +25,16 @@ "create_task" ] }, + "DeleteDeliveryVehicle": { + "methods": [ + "delete_delivery_vehicle" + ] + }, + "DeleteTask": { + "methods": [ + "delete_task" + ] + }, "GetDeliveryVehicle": { "methods": [ "get_delivery_vehicle" @@ -80,6 +90,16 @@ "create_task" ] }, + "DeleteDeliveryVehicle": { + "methods": [ + "delete_delivery_vehicle" + ] + }, + "DeleteTask": { + "methods": [ + "delete_task" + ] + }, "GetDeliveryVehicle": { "methods": [ "get_delivery_vehicle" @@ -135,6 +155,16 @@ "create_task" ] }, + "DeleteDeliveryVehicle": { + "methods": [ + "delete_delivery_vehicle" + ] + }, + "DeleteTask": { + "methods": [ + "delete_task" + ] + }, "GetDeliveryVehicle": { "methods": [ "get_delivery_vehicle" diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/gapic_version.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/gapic_version.py index 80a5f33e3aea..558c8aab67c5 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/gapic_version.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/gapic_version.py @@ -13,4 +13,4 @@ # See the License for the specific language governing permissions and # limitations under the License. # -__version__ = "0.2.9" # {x-release-please-version} +__version__ = "0.0.0" # {x-release-please-version} diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/async_client.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/async_client.py index c9637c7758f2..e49e9909398b 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/async_client.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/async_client.py @@ -420,7 +420,10 @@ async def sample_create_delivery_vehicle(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([parent, delivery_vehicle, delivery_vehicle_id]) + flattened_params = [parent, delivery_vehicle, delivery_vehicle_id] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -548,7 +551,10 @@ async def sample_get_delivery_vehicle(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([name]) + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -597,6 +603,118 @@ async def sample_get_delivery_vehicle(): # Done; return the response. return response + async def delete_delivery_vehicle( + self, + request: Optional[ + Union[delivery_api.DeleteDeliveryVehicleRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Deletes a DeliveryVehicle from the Fleet Engine. + + Returns FAILED_PRECONDITION if the DeliveryVehicle has OPEN + Tasks assigned to it. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.maps import fleetengine_delivery_v1 + + async def sample_delete_delivery_vehicle(): + # Create a client + client = fleetengine_delivery_v1.DeliveryServiceAsyncClient() + + # Initialize request argument(s) + request = fleetengine_delivery_v1.DeleteDeliveryVehicleRequest( + name="name_value", + ) + + # Make the request + await client.delete_delivery_vehicle(request=request) + + Args: + request (Optional[Union[google.maps.fleetengine_delivery_v1.types.DeleteDeliveryVehicleRequest, dict]]): + The request object. DeleteDeliveryVehicle request + message. + name (:class:`str`): + Required. Must be in the format + ``providers/{provider}/deliveryVehicles/{delivery_vehicle}``. + The ``provider`` must be the Google Cloud Project ID. + For example, ``sample-cloud-project``. + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + 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, 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`. + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, delivery_api.DeleteDeliveryVehicleRequest): + request = delivery_api.DeleteDeliveryVehicleRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.delete_delivery_vehicle + ] + + header_params = {} + + routing_param_regex = re.compile("^(?Pproviders/[^/]+)$") + regex_match = routing_param_regex.match(request.name) + if regex_match and regex_match.group("provider_id"): + header_params["provider_id"] = regex_match.group("provider_id") + + if header_params: + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata(header_params), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + async def update_delivery_vehicle( self, request: Optional[ @@ -693,7 +811,10 @@ async def sample_update_delivery_vehicle(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([delivery_vehicle, update_mask]) + flattened_params = [delivery_vehicle, update_mask] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -971,7 +1092,10 @@ async def sample_create_task(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([parent, task, task_id]) + flattened_params = [parent, task, task_id] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1104,7 +1228,10 @@ async def sample_get_task(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([name]) + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1151,6 +1278,115 @@ async def sample_get_task(): # Done; return the response. return response + async def delete_task( + self, + request: Optional[Union[delivery_api.DeleteTaskRequest, dict]] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Deletes a single Task. + + Returns FAILED_PRECONDITION if the Task is OPEN and assigned to + a DeliveryVehicle. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.maps import fleetengine_delivery_v1 + + async def sample_delete_task(): + # Create a client + client = fleetengine_delivery_v1.DeliveryServiceAsyncClient() + + # Initialize request argument(s) + request = fleetengine_delivery_v1.DeleteTaskRequest( + name="name_value", + ) + + # Make the request + await client.delete_task(request=request) + + Args: + request (Optional[Union[google.maps.fleetengine_delivery_v1.types.DeleteTaskRequest, dict]]): + The request object. DeleteTask request message. + name (:class:`str`): + Required. Must be in the format + ``providers/{provider}/tasks/{task}``. The ``provider`` + must be the Google Cloud Project ID. For example, + ``sample-cloud-project``. + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + 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, 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`. + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, delivery_api.DeleteTaskRequest): + request = delivery_api.DeleteTaskRequest(request) + + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._client._transport._wrapped_methods[ + self._client._transport.delete_task + ] + + header_params = {} + + routing_param_regex = re.compile("^(?Pproviders/[^/]+)$") + regex_match = routing_param_regex.match(request.name) + if regex_match and regex_match.group("provider_id"): + header_params["provider_id"] = regex_match.group("provider_id") + + if header_params: + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata(header_params), + ) + + # Validate the universe domain. + self._client._validate_universe_domain() + + # Send the request. + await rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + async def update_task( self, request: Optional[Union[delivery_api.UpdateTaskRequest, dict]] = None, @@ -1262,7 +1498,10 @@ async def sample_update_task(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([task, update_mask]) + flattened_params = [task, update_mask] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1383,7 +1622,10 @@ async def sample_list_tasks(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([parent]) + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1514,7 +1756,10 @@ async def sample_get_task_tracking_info(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([name]) + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1633,7 +1878,10 @@ async def sample_list_delivery_vehicles(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([parent]) + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/client.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/client.py index 61af63b1e925..694a49f41dcd 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/client.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/client.py @@ -866,7 +866,10 @@ def sample_create_delivery_vehicle(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([parent, delivery_vehicle, delivery_vehicle_id]) + flattened_params = [parent, delivery_vehicle, delivery_vehicle_id] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -991,7 +994,10 @@ def sample_get_delivery_vehicle(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([name]) + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1037,6 +1043,115 @@ def sample_get_delivery_vehicle(): # Done; return the response. return response + def delete_delivery_vehicle( + self, + request: Optional[ + Union[delivery_api.DeleteDeliveryVehicleRequest, dict] + ] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Deletes a DeliveryVehicle from the Fleet Engine. + + Returns FAILED_PRECONDITION if the DeliveryVehicle has OPEN + Tasks assigned to it. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.maps import fleetengine_delivery_v1 + + def sample_delete_delivery_vehicle(): + # Create a client + client = fleetengine_delivery_v1.DeliveryServiceClient() + + # Initialize request argument(s) + request = fleetengine_delivery_v1.DeleteDeliveryVehicleRequest( + name="name_value", + ) + + # Make the request + client.delete_delivery_vehicle(request=request) + + Args: + request (Union[google.maps.fleetengine_delivery_v1.types.DeleteDeliveryVehicleRequest, dict]): + The request object. DeleteDeliveryVehicle request + message. + name (str): + Required. Must be in the format + ``providers/{provider}/deliveryVehicles/{delivery_vehicle}``. + The ``provider`` must be the Google Cloud Project ID. + For example, ``sample-cloud-project``. + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + 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, 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`. + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, delivery_api.DeleteDeliveryVehicleRequest): + request = delivery_api.DeleteDeliveryVehicleRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.delete_delivery_vehicle] + + header_params = {} + + routing_param_regex = re.compile("^(?Pproviders/[^/]+)$") + regex_match = routing_param_regex.match(request.name) + if regex_match and regex_match.group("provider_id"): + header_params["provider_id"] = regex_match.group("provider_id") + + if header_params: + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata(header_params), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + def update_delivery_vehicle( self, request: Optional[ @@ -1133,7 +1248,10 @@ def sample_update_delivery_vehicle(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([delivery_vehicle, update_mask]) + flattened_params = [delivery_vehicle, update_mask] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1406,7 +1524,10 @@ def sample_create_task(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([parent, task, task_id]) + flattened_params = [parent, task, task_id] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1536,7 +1657,10 @@ def sample_get_task(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([name]) + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1582,6 +1706,112 @@ def sample_get_task(): # Done; return the response. return response + def delete_task( + self, + request: Optional[Union[delivery_api.DeleteTaskRequest, dict]] = None, + *, + name: Optional[str] = None, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Union[float, object] = gapic_v1.method.DEFAULT, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ) -> None: + r"""Deletes a single Task. + + Returns FAILED_PRECONDITION if the Task is OPEN and assigned to + a DeliveryVehicle. + + .. code-block:: python + + # This snippet has been automatically generated and should be regarded as a + # code template only. + # It will require modifications to work: + # - It may require correct/in-range values for request initialization. + # - It may require specifying regional endpoints when creating the service + # client as shown in: + # https://googleapis.dev/python/google-api-core/latest/client_options.html + from google.maps import fleetengine_delivery_v1 + + def sample_delete_task(): + # Create a client + client = fleetengine_delivery_v1.DeliveryServiceClient() + + # Initialize request argument(s) + request = fleetengine_delivery_v1.DeleteTaskRequest( + name="name_value", + ) + + # Make the request + client.delete_task(request=request) + + Args: + request (Union[google.maps.fleetengine_delivery_v1.types.DeleteTaskRequest, dict]): + The request object. DeleteTask request message. + name (str): + Required. Must be in the format + ``providers/{provider}/tasks/{task}``. The ``provider`` + must be the Google Cloud Project ID. For example, + ``sample-cloud-project``. + + This corresponds to the ``name`` field + on the ``request`` instance; if ``request`` is provided, this + should not be set. + 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, 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`. + """ + # Create or coerce a protobuf request object. + # - Quick check: If we got a request object, we should *not* have + # gotten any keyword arguments that map to the request. + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) + if request is not None and has_flattened_params: + raise ValueError( + "If the `request` argument is set, then none of " + "the individual field arguments should be set." + ) + + # - Use the request object if provided (there's no risk of modifying the input as + # there are no flattened fields), or create one. + if not isinstance(request, delivery_api.DeleteTaskRequest): + request = delivery_api.DeleteTaskRequest(request) + # If we have keyword arguments corresponding to fields on the + # request, apply these. + if name is not None: + request.name = name + + # Wrap the RPC method; this adds retry and timeout information, + # and friendly error handling. + rpc = self._transport._wrapped_methods[self._transport.delete_task] + + header_params = {} + + routing_param_regex = re.compile("^(?Pproviders/[^/]+)$") + regex_match = routing_param_regex.match(request.name) + if regex_match and regex_match.group("provider_id"): + header_params["provider_id"] = regex_match.group("provider_id") + + if header_params: + metadata = tuple(metadata) + ( + gapic_v1.routing_header.to_grpc_metadata(header_params), + ) + + # Validate the universe domain. + self._validate_universe_domain() + + # Send the request. + rpc( + request, + retry=retry, + timeout=timeout, + metadata=metadata, + ) + def update_task( self, request: Optional[Union[delivery_api.UpdateTaskRequest, dict]] = None, @@ -1693,7 +1923,10 @@ def sample_update_task(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([task, update_mask]) + flattened_params = [task, update_mask] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1811,7 +2044,10 @@ def sample_list_tasks(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([parent]) + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -1939,7 +2175,10 @@ def sample_get_task_tracking_info(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([name]) + flattened_params = [name] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " @@ -2055,7 +2294,10 @@ def sample_list_delivery_vehicles(): # Create or coerce a protobuf request object. # - Quick check: If we got a request object, we should *not* have # gotten any keyword arguments that map to the request. - has_flattened_params = any([parent]) + flattened_params = [parent] + has_flattened_params = ( + len([param for param in flattened_params if param is not None]) > 0 + ) if request is not None and has_flattened_params: raise ValueError( "If the `request` argument is set, then none of " diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/base.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/base.py index 4403ff08e635..8a74f15f1324 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/base.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/base.py @@ -23,6 +23,7 @@ import google.auth # type: ignore from google.auth import credentials as ga_credentials # type: ignore from google.oauth2 import service_account # type: ignore +from google.protobuf import empty_pb2 # type: ignore from google.maps.fleetengine_delivery_v1 import gapic_version as package_version from google.maps.fleetengine_delivery_v1.types import ( @@ -161,6 +162,11 @@ def _prep_wrapped_messages(self, client_info): default_timeout=60.0, client_info=client_info, ), + self.delete_delivery_vehicle: gapic_v1.method.wrap_method( + self.delete_delivery_vehicle, + default_timeout=None, + client_info=client_info, + ), self.update_delivery_vehicle: gapic_v1.method.wrap_method( self.update_delivery_vehicle, default_retry=retries.Retry( @@ -217,6 +223,11 @@ def _prep_wrapped_messages(self, client_info): default_timeout=60.0, client_info=client_info, ), + self.delete_task: gapic_v1.method.wrap_method( + self.delete_task, + default_timeout=None, + client_info=client_info, + ), self.update_task: gapic_v1.method.wrap_method( self.update_task, default_retry=retries.Retry( @@ -308,6 +319,15 @@ def get_delivery_vehicle( ]: raise NotImplementedError() + @property + def delete_delivery_vehicle( + self, + ) -> Callable[ + [delivery_api.DeleteDeliveryVehicleRequest], + Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]], + ]: + raise NotImplementedError() + @property def update_delivery_vehicle( self, @@ -348,6 +368,15 @@ def get_task( ]: raise NotImplementedError() + @property + def delete_task( + self, + ) -> Callable[ + [delivery_api.DeleteTaskRequest], + Union[empty_pb2.Empty, Awaitable[empty_pb2.Empty]], + ]: + raise NotImplementedError() + @property def update_task( self, diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/grpc.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/grpc.py index abfd09fc1a50..db4952013e79 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/grpc.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/grpc.py @@ -23,6 +23,7 @@ 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.protobuf import empty_pb2 # type: ignore from google.protobuf.json_format import MessageToJson import google.protobuf.message import grpc # type: ignore @@ -381,6 +382,35 @@ def get_delivery_vehicle( ) return self._stubs["get_delivery_vehicle"] + @property + def delete_delivery_vehicle( + self, + ) -> Callable[[delivery_api.DeleteDeliveryVehicleRequest], empty_pb2.Empty]: + r"""Return a callable for the delete delivery vehicle method over gRPC. + + Deletes a DeliveryVehicle from the Fleet Engine. + + Returns FAILED_PRECONDITION if the DeliveryVehicle has OPEN + Tasks assigned to it. + + Returns: + Callable[[~.DeleteDeliveryVehicleRequest], + ~.Empty]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "delete_delivery_vehicle" not in self._stubs: + self._stubs["delete_delivery_vehicle"] = self._logged_channel.unary_unary( + "/maps.fleetengine.delivery.v1.DeliveryService/DeleteDeliveryVehicle", + request_serializer=delivery_api.DeleteDeliveryVehicleRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_delivery_vehicle"] + @property def update_delivery_vehicle( self, @@ -493,6 +523,35 @@ def get_task(self) -> Callable[[delivery_api.GetTaskRequest], tasks.Task]: ) return self._stubs["get_task"] + @property + def delete_task( + self, + ) -> Callable[[delivery_api.DeleteTaskRequest], empty_pb2.Empty]: + r"""Return a callable for the delete task method over gRPC. + + Deletes a single Task. + + Returns FAILED_PRECONDITION if the Task is OPEN and assigned to + a DeliveryVehicle. + + Returns: + Callable[[~.DeleteTaskRequest], + ~.Empty]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "delete_task" not in self._stubs: + self._stubs["delete_task"] = self._logged_channel.unary_unary( + "/maps.fleetengine.delivery.v1.DeliveryService/DeleteTask", + request_serializer=delivery_api.DeleteTaskRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_task"] + @property def update_task(self) -> Callable[[delivery_api.UpdateTaskRequest], tasks.Task]: r"""Return a callable for the update task method over gRPC. diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/grpc_asyncio.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/grpc_asyncio.py index a6f8b24a0896..7c90f9b16195 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/grpc_asyncio.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/grpc_asyncio.py @@ -25,6 +25,7 @@ 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.protobuf import empty_pb2 # type: ignore from google.protobuf.json_format import MessageToJson import google.protobuf.message import grpc # type: ignore @@ -390,6 +391,37 @@ def get_delivery_vehicle( ) return self._stubs["get_delivery_vehicle"] + @property + def delete_delivery_vehicle( + self, + ) -> Callable[ + [delivery_api.DeleteDeliveryVehicleRequest], Awaitable[empty_pb2.Empty] + ]: + r"""Return a callable for the delete delivery vehicle method over gRPC. + + Deletes a DeliveryVehicle from the Fleet Engine. + + Returns FAILED_PRECONDITION if the DeliveryVehicle has OPEN + Tasks assigned to it. + + Returns: + Callable[[~.DeleteDeliveryVehicleRequest], + Awaitable[~.Empty]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "delete_delivery_vehicle" not in self._stubs: + self._stubs["delete_delivery_vehicle"] = self._logged_channel.unary_unary( + "/maps.fleetengine.delivery.v1.DeliveryService/DeleteDeliveryVehicle", + request_serializer=delivery_api.DeleteDeliveryVehicleRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_delivery_vehicle"] + @property def update_delivery_vehicle( self, @@ -508,6 +540,35 @@ def get_task( ) return self._stubs["get_task"] + @property + def delete_task( + self, + ) -> Callable[[delivery_api.DeleteTaskRequest], Awaitable[empty_pb2.Empty]]: + r"""Return a callable for the delete task method over gRPC. + + Deletes a single Task. + + Returns FAILED_PRECONDITION if the Task is OPEN and assigned to + a DeliveryVehicle. + + Returns: + Callable[[~.DeleteTaskRequest], + Awaitable[~.Empty]]: + A function that, when called, will call the underlying RPC + on the server. + """ + # Generate a "stub function" on-the-fly which will actually make + # the request. + # gRPC handles serialization and deserialization, so we just need + # to pass in the functions for each. + if "delete_task" not in self._stubs: + self._stubs["delete_task"] = self._logged_channel.unary_unary( + "/maps.fleetengine.delivery.v1.DeliveryService/DeleteTask", + request_serializer=delivery_api.DeleteTaskRequest.serialize, + response_deserializer=empty_pb2.Empty.FromString, + ) + return self._stubs["delete_task"] + @property def update_task( self, @@ -652,6 +713,11 @@ def _prep_wrapped_messages(self, client_info): default_timeout=60.0, client_info=client_info, ), + self.delete_delivery_vehicle: self._wrap_method( + self.delete_delivery_vehicle, + default_timeout=None, + client_info=client_info, + ), self.update_delivery_vehicle: self._wrap_method( self.update_delivery_vehicle, default_retry=retries.AsyncRetry( @@ -708,6 +774,11 @@ def _prep_wrapped_messages(self, client_info): default_timeout=60.0, client_info=client_info, ), + self.delete_task: self._wrap_method( + self.delete_task, + default_timeout=None, + client_info=client_info, + ), self.update_task: self._wrap_method( self.update_task, default_retry=retries.AsyncRetry( diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/rest.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/rest.py index 8bdc7a757cf8..8842603215aa 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/rest.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/rest.py @@ -24,6 +24,7 @@ from google.api_core import retry as retries from google.auth import credentials as ga_credentials # type: ignore from google.auth.transport.requests import AuthorizedSession # type: ignore +from google.protobuf import empty_pb2 # type: ignore from google.protobuf import json_format from requests import __version__ as requests_version @@ -97,6 +98,14 @@ def post_create_task(self, response): logging.log(f"Received response: {response}") return response + def pre_delete_delivery_vehicle(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + + def pre_delete_task(self, request, metadata): + logging.log(f"Received request: {request}") + return request, metadata + def pre_get_delivery_vehicle(self, request, metadata): logging.log(f"Received request: {request}") return request, metadata @@ -302,6 +311,33 @@ def post_create_task_with_metadata( """ return response, metadata + def pre_delete_delivery_vehicle( + self, + request: delivery_api.DeleteDeliveryVehicleRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[ + delivery_api.DeleteDeliveryVehicleRequest, + Sequence[Tuple[str, Union[str, bytes]]], + ]: + """Pre-rpc interceptor for delete_delivery_vehicle + + Override in a subclass to manipulate the request or metadata + before they are sent to the DeliveryService server. + """ + return request, metadata + + def pre_delete_task( + self, + request: delivery_api.DeleteTaskRequest, + metadata: Sequence[Tuple[str, Union[str, bytes]]], + ) -> Tuple[delivery_api.DeleteTaskRequest, Sequence[Tuple[str, Union[str, bytes]]]]: + """Pre-rpc interceptor for delete_task + + Override in a subclass to manipulate the request or metadata + before they are sent to the DeliveryService server. + """ + return request, metadata + def pre_get_delivery_vehicle( self, request: delivery_api.GetDeliveryVehicleRequest, @@ -1211,6 +1247,224 @@ def __call__( ) return resp + class _DeleteDeliveryVehicle( + _BaseDeliveryServiceRestTransport._BaseDeleteDeliveryVehicle, + DeliveryServiceRestStub, + ): + def __hash__(self): + return hash("DeliveryServiceRestTransport.DeleteDeliveryVehicle") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: delivery_api.DeleteDeliveryVehicleRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ): + r"""Call the delete delivery vehicle method over HTTP. + + Args: + request (~.delivery_api.DeleteDeliveryVehicleRequest): + The request object. DeleteDeliveryVehicle request + message. + 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, 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`. + """ + + http_options = ( + _BaseDeliveryServiceRestTransport._BaseDeleteDeliveryVehicle._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_delivery_vehicle( + request, metadata + ) + transcoded_request = _BaseDeliveryServiceRestTransport._BaseDeleteDeliveryVehicle._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseDeliveryServiceRestTransport._BaseDeleteDeliveryVehicle._get_query_params_json( + 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 maps.fleetengine.delivery_v1.DeliveryServiceClient.DeleteDeliveryVehicle", + extra={ + "serviceName": "maps.fleetengine.delivery.v1.DeliveryService", + "rpcName": "DeleteDeliveryVehicle", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = ( + DeliveryServiceRestTransport._DeleteDeliveryVehicle._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + + class _DeleteTask( + _BaseDeliveryServiceRestTransport._BaseDeleteTask, DeliveryServiceRestStub + ): + def __hash__(self): + return hash("DeliveryServiceRestTransport.DeleteTask") + + @staticmethod + def _get_response( + host, + metadata, + query_params, + session, + timeout, + transcoded_request, + body=None, + ): + uri = transcoded_request["uri"] + method = transcoded_request["method"] + headers = dict(metadata) + headers["Content-Type"] = "application/json" + response = getattr(session, method)( + "{host}{uri}".format(host=host, uri=uri), + timeout=timeout, + headers=headers, + params=rest_helpers.flatten_query_params(query_params, strict=True), + ) + return response + + def __call__( + self, + request: delivery_api.DeleteTaskRequest, + *, + retry: OptionalRetry = gapic_v1.method.DEFAULT, + timeout: Optional[float] = None, + metadata: Sequence[Tuple[str, Union[str, bytes]]] = (), + ): + r"""Call the delete task method over HTTP. + + Args: + request (~.delivery_api.DeleteTaskRequest): + The request object. DeleteTask request message. + 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, 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`. + """ + + http_options = ( + _BaseDeliveryServiceRestTransport._BaseDeleteTask._get_http_options() + ) + + request, metadata = self._interceptor.pre_delete_task(request, metadata) + transcoded_request = _BaseDeliveryServiceRestTransport._BaseDeleteTask._get_transcoded_request( + http_options, request + ) + + # Jsonify the query params + query_params = _BaseDeliveryServiceRestTransport._BaseDeleteTask._get_query_params_json( + 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 maps.fleetengine.delivery_v1.DeliveryServiceClient.DeleteTask", + extra={ + "serviceName": "maps.fleetengine.delivery.v1.DeliveryService", + "rpcName": "DeleteTask", + "httpRequest": http_request, + "metadata": http_request["headers"], + }, + ) + + # Send the request + response = DeliveryServiceRestTransport._DeleteTask._get_response( + self._host, + metadata, + query_params, + self._session, + timeout, + transcoded_request, + ) + + # In case of error, raise the appropriate core_exceptions.GoogleAPICallError exception + # subclass. + if response.status_code >= 400: + raise core_exceptions.from_http_response(response) + class _GetDeliveryVehicle( _BaseDeliveryServiceRestTransport._BaseGetDeliveryVehicle, DeliveryServiceRestStub, @@ -2349,6 +2603,22 @@ def create_task(self) -> Callable[[delivery_api.CreateTaskRequest], tasks.Task]: # In C++ this would require a dynamic_cast return self._CreateTask(self._session, self._host, self._interceptor) # type: ignore + @property + def delete_delivery_vehicle( + self, + ) -> Callable[[delivery_api.DeleteDeliveryVehicleRequest], empty_pb2.Empty]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._DeleteDeliveryVehicle(self._session, self._host, self._interceptor) # type: ignore + + @property + def delete_task( + self, + ) -> Callable[[delivery_api.DeleteTaskRequest], empty_pb2.Empty]: + # The return type is fine, but mypy isn't sophisticated enough to determine what's going on here. + # In C++ this would require a dynamic_cast + return self._DeleteTask(self._session, self._host, self._interceptor) # type: ignore + @property def get_delivery_vehicle( self, diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/rest_base.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/rest_base.py index 84681d7e12a9..6555dc05df3f 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/rest_base.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/services/delivery_service/transports/rest_base.py @@ -18,6 +18,7 @@ from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, Union from google.api_core import gapic_v1, path_template +from google.protobuf import empty_pb2 # type: ignore from google.protobuf import json_format from google.maps.fleetengine_delivery_v1.types import ( @@ -267,6 +268,100 @@ def _get_query_params_json(transcoded_request): query_params["$alt"] = "json;enum-encoding=int" return query_params + class _BaseDeleteDeliveryVehicle: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=providers/*/deliveryVehicles/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = delivery_api.DeleteDeliveryVehicleRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseDeliveryServiceRestTransport._BaseDeleteDeliveryVehicle._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + + class _BaseDeleteTask: + def __hash__(self): # pragma: NO COVER + return NotImplementedError("__hash__ must be implemented.") + + __REQUIRED_FIELDS_DEFAULT_VALUES: Dict[str, Any] = {} + + @classmethod + def _get_unset_required_fields(cls, message_dict): + return { + k: v + for k, v in cls.__REQUIRED_FIELDS_DEFAULT_VALUES.items() + if k not in message_dict + } + + @staticmethod + def _get_http_options(): + http_options: List[Dict[str, str]] = [ + { + "method": "delete", + "uri": "/v1/{name=providers/*/tasks/*}", + }, + ] + return http_options + + @staticmethod + def _get_transcoded_request(http_options, request): + pb_request = delivery_api.DeleteTaskRequest.pb(request) + transcoded_request = path_template.transcode(http_options, pb_request) + return transcoded_request + + @staticmethod + def _get_query_params_json(transcoded_request): + query_params = json.loads( + json_format.MessageToJson( + transcoded_request["query_params"], + use_integers_for_enums=True, + ) + ) + query_params.update( + _BaseDeliveryServiceRestTransport._BaseDeleteTask._get_unset_required_fields( + query_params + ) + ) + + query_params["$alt"] = "json;enum-encoding=int" + return query_params + class _BaseGetDeliveryVehicle: def __hash__(self): # pragma: NO COVER return NotImplementedError("__hash__ must be implemented.") diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/types/__init__.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/types/__init__.py index ba147eb22b17..8ffcb9467793 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/types/__init__.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/types/__init__.py @@ -26,6 +26,8 @@ BatchCreateTasksResponse, CreateDeliveryVehicleRequest, CreateTaskRequest, + DeleteDeliveryVehicleRequest, + DeleteTaskRequest, GetDeliveryVehicleRequest, GetTaskRequest, GetTaskTrackingInfoRequest, @@ -57,6 +59,8 @@ "BatchCreateTasksResponse", "CreateDeliveryVehicleRequest", "CreateTaskRequest", + "DeleteDeliveryVehicleRequest", + "DeleteTaskRequest", "GetDeliveryVehicleRequest", "GetTaskRequest", "GetTaskTrackingInfoRequest", diff --git a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/types/delivery_api.py b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/types/delivery_api.py index 203cfa44affd..e8cbe619e574 100644 --- a/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/types/delivery_api.py +++ b/packages/google-maps-fleetengine-delivery/google/maps/fleetengine_delivery_v1/types/delivery_api.py @@ -32,6 +32,7 @@ manifest={ "CreateDeliveryVehicleRequest", "GetDeliveryVehicleRequest", + "DeleteDeliveryVehicleRequest", "ListDeliveryVehiclesRequest", "ListDeliveryVehiclesResponse", "UpdateDeliveryVehicleRequest", @@ -39,6 +40,7 @@ "BatchCreateTasksResponse", "CreateTaskRequest", "GetTaskRequest", + "DeleteTaskRequest", "UpdateTaskRequest", "ListTasksRequest", "ListTasksResponse", @@ -127,6 +129,31 @@ class GetDeliveryVehicleRequest(proto.Message): ) +class DeleteDeliveryVehicleRequest(proto.Message): + r"""DeleteDeliveryVehicle request message. + + Attributes: + header (google.maps.fleetengine_delivery_v1.types.DeliveryRequestHeader): + Optional. The standard Delivery API request + header. + name (str): + Required. Must be in the format + ``providers/{provider}/deliveryVehicles/{delivery_vehicle}``. + The ``provider`` must be the Google Cloud Project ID. For + example, ``sample-cloud-project``. + """ + + header: mfd_header.DeliveryRequestHeader = proto.Field( + proto.MESSAGE, + number=1, + message=mfd_header.DeliveryRequestHeader, + ) + name: str = proto.Field( + proto.STRING, + number=2, + ) + + class ListDeliveryVehiclesRequest(proto.Message): r"""The ``ListDeliveryVehicles`` request message. @@ -431,6 +458,31 @@ class GetTaskRequest(proto.Message): ) +class DeleteTaskRequest(proto.Message): + r"""DeleteTask request message. + + Attributes: + header (google.maps.fleetengine_delivery_v1.types.DeliveryRequestHeader): + Optional. The standard Delivery API request + header. + name (str): + Required. Must be in the format + ``providers/{provider}/tasks/{task}``. The ``provider`` must + be the Google Cloud Project ID. For example, + ``sample-cloud-project``. + """ + + header: mfd_header.DeliveryRequestHeader = proto.Field( + proto.MESSAGE, + number=1, + message=mfd_header.DeliveryRequestHeader, + ) + name: str = proto.Field( + proto.STRING, + number=2, + ) + + class UpdateTaskRequest(proto.Message): r"""The ``UpdateTask`` request message. diff --git a/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_async.py b/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_async.py new file mode 100644 index 000000000000..8389774a537c --- /dev/null +++ b/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_async.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteDeliveryVehicle +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-maps-fleetengine-delivery + + +# [START fleetengine_v1_generated_DeliveryService_DeleteDeliveryVehicle_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.maps import fleetengine_delivery_v1 + + +async def sample_delete_delivery_vehicle(): + # Create a client + client = fleetengine_delivery_v1.DeliveryServiceAsyncClient() + + # Initialize request argument(s) + request = fleetengine_delivery_v1.DeleteDeliveryVehicleRequest( + name="name_value", + ) + + # Make the request + await client.delete_delivery_vehicle(request=request) + + +# [END fleetengine_v1_generated_DeliveryService_DeleteDeliveryVehicle_async] diff --git a/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_sync.py b/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_sync.py new file mode 100644 index 000000000000..31bc417c65d8 --- /dev/null +++ b/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_sync.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteDeliveryVehicle +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-maps-fleetengine-delivery + + +# [START fleetengine_v1_generated_DeliveryService_DeleteDeliveryVehicle_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.maps import fleetengine_delivery_v1 + + +def sample_delete_delivery_vehicle(): + # Create a client + client = fleetengine_delivery_v1.DeliveryServiceClient() + + # Initialize request argument(s) + request = fleetengine_delivery_v1.DeleteDeliveryVehicleRequest( + name="name_value", + ) + + # Make the request + client.delete_delivery_vehicle(request=request) + + +# [END fleetengine_v1_generated_DeliveryService_DeleteDeliveryVehicle_sync] diff --git a/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_task_async.py b/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_task_async.py new file mode 100644 index 000000000000..963db729e580 --- /dev/null +++ b/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_task_async.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteTask +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-maps-fleetengine-delivery + + +# [START fleetengine_v1_generated_DeliveryService_DeleteTask_async] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.maps import fleetengine_delivery_v1 + + +async def sample_delete_task(): + # Create a client + client = fleetengine_delivery_v1.DeliveryServiceAsyncClient() + + # Initialize request argument(s) + request = fleetengine_delivery_v1.DeleteTaskRequest( + name="name_value", + ) + + # Make the request + await client.delete_task(request=request) + + +# [END fleetengine_v1_generated_DeliveryService_DeleteTask_async] diff --git a/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_task_sync.py b/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_task_sync.py new file mode 100644 index 000000000000..40d6be6420ec --- /dev/null +++ b/packages/google-maps-fleetengine-delivery/samples/generated_samples/fleetengine_v1_generated_delivery_service_delete_task_sync.py @@ -0,0 +1,50 @@ +# -*- coding: utf-8 -*- +# Copyright 2024 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Generated code. DO NOT EDIT! +# +# Snippet for DeleteTask +# NOTE: This snippet has been automatically generated for illustrative purposes only. +# It may require modifications to work in your environment. + +# To install the latest published package dependency, execute the following: +# python3 -m pip install google-maps-fleetengine-delivery + + +# [START fleetengine_v1_generated_DeliveryService_DeleteTask_sync] +# This snippet has been automatically generated and should be regarded as a +# code template only. +# It will require modifications to work: +# - It may require correct/in-range values for request initialization. +# - It may require specifying regional endpoints when creating the service +# client as shown in: +# https://googleapis.dev/python/google-api-core/latest/client_options.html +from google.maps import fleetengine_delivery_v1 + + +def sample_delete_task(): + # Create a client + client = fleetengine_delivery_v1.DeliveryServiceClient() + + # Initialize request argument(s) + request = fleetengine_delivery_v1.DeleteTaskRequest( + name="name_value", + ) + + # Make the request + client.delete_task(request=request) + + +# [END fleetengine_v1_generated_DeliveryService_DeleteTask_sync] diff --git a/packages/google-maps-fleetengine-delivery/samples/generated_samples/snippet_metadata_maps.fleetengine.delivery.v1.json b/packages/google-maps-fleetengine-delivery/samples/generated_samples/snippet_metadata_maps.fleetengine.delivery.v1.json index 65e6cf821000..d9eabeb8dfa6 100644 --- a/packages/google-maps-fleetengine-delivery/samples/generated_samples/snippet_metadata_maps.fleetengine.delivery.v1.json +++ b/packages/google-maps-fleetengine-delivery/samples/generated_samples/snippet_metadata_maps.fleetengine.delivery.v1.json @@ -8,7 +8,7 @@ ], "language": "PYTHON", "name": "google-maps-fleetengine-delivery", - "version": "0.2.9" + "version": "0.1.0" }, "snippets": [ { @@ -518,6 +518,316 @@ ], "title": "fleetengine_v1_generated_delivery_service_create_task_sync.py" }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.maps.fleetengine_delivery_v1.DeliveryServiceAsyncClient", + "shortName": "DeliveryServiceAsyncClient" + }, + "fullName": "google.maps.fleetengine_delivery_v1.DeliveryServiceAsyncClient.delete_delivery_vehicle", + "method": { + "fullName": "maps.fleetengine.delivery.v1.DeliveryService.DeleteDeliveryVehicle", + "service": { + "fullName": "maps.fleetengine.delivery.v1.DeliveryService", + "shortName": "DeliveryService" + }, + "shortName": "DeleteDeliveryVehicle" + }, + "parameters": [ + { + "name": "request", + "type": "google.maps.fleetengine_delivery_v1.types.DeleteDeliveryVehicleRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "shortName": "delete_delivery_vehicle" + }, + "description": "Sample for DeleteDeliveryVehicle", + "file": "fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "fleetengine_v1_generated_DeliveryService_DeleteDeliveryVehicle_async", + "segments": [ + { + "end": 49, + "start": 27, + "type": "FULL" + }, + { + "end": 49, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.maps.fleetengine_delivery_v1.DeliveryServiceClient", + "shortName": "DeliveryServiceClient" + }, + "fullName": "google.maps.fleetengine_delivery_v1.DeliveryServiceClient.delete_delivery_vehicle", + "method": { + "fullName": "maps.fleetengine.delivery.v1.DeliveryService.DeleteDeliveryVehicle", + "service": { + "fullName": "maps.fleetengine.delivery.v1.DeliveryService", + "shortName": "DeliveryService" + }, + "shortName": "DeleteDeliveryVehicle" + }, + "parameters": [ + { + "name": "request", + "type": "google.maps.fleetengine_delivery_v1.types.DeleteDeliveryVehicleRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "shortName": "delete_delivery_vehicle" + }, + "description": "Sample for DeleteDeliveryVehicle", + "file": "fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "fleetengine_v1_generated_DeliveryService_DeleteDeliveryVehicle_sync", + "segments": [ + { + "end": 49, + "start": 27, + "type": "FULL" + }, + { + "end": 49, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "fleetengine_v1_generated_delivery_service_delete_delivery_vehicle_sync.py" + }, + { + "canonical": true, + "clientMethod": { + "async": true, + "client": { + "fullName": "google.maps.fleetengine_delivery_v1.DeliveryServiceAsyncClient", + "shortName": "DeliveryServiceAsyncClient" + }, + "fullName": "google.maps.fleetengine_delivery_v1.DeliveryServiceAsyncClient.delete_task", + "method": { + "fullName": "maps.fleetengine.delivery.v1.DeliveryService.DeleteTask", + "service": { + "fullName": "maps.fleetengine.delivery.v1.DeliveryService", + "shortName": "DeliveryService" + }, + "shortName": "DeleteTask" + }, + "parameters": [ + { + "name": "request", + "type": "google.maps.fleetengine_delivery_v1.types.DeleteTaskRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "shortName": "delete_task" + }, + "description": "Sample for DeleteTask", + "file": "fleetengine_v1_generated_delivery_service_delete_task_async.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "fleetengine_v1_generated_DeliveryService_DeleteTask_async", + "segments": [ + { + "end": 49, + "start": 27, + "type": "FULL" + }, + { + "end": 49, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "fleetengine_v1_generated_delivery_service_delete_task_async.py" + }, + { + "canonical": true, + "clientMethod": { + "client": { + "fullName": "google.maps.fleetengine_delivery_v1.DeliveryServiceClient", + "shortName": "DeliveryServiceClient" + }, + "fullName": "google.maps.fleetengine_delivery_v1.DeliveryServiceClient.delete_task", + "method": { + "fullName": "maps.fleetengine.delivery.v1.DeliveryService.DeleteTask", + "service": { + "fullName": "maps.fleetengine.delivery.v1.DeliveryService", + "shortName": "DeliveryService" + }, + "shortName": "DeleteTask" + }, + "parameters": [ + { + "name": "request", + "type": "google.maps.fleetengine_delivery_v1.types.DeleteTaskRequest" + }, + { + "name": "name", + "type": "str" + }, + { + "name": "retry", + "type": "google.api_core.retry.Retry" + }, + { + "name": "timeout", + "type": "float" + }, + { + "name": "metadata", + "type": "Sequence[Tuple[str, Union[str, bytes]]]" + } + ], + "shortName": "delete_task" + }, + "description": "Sample for DeleteTask", + "file": "fleetengine_v1_generated_delivery_service_delete_task_sync.py", + "language": "PYTHON", + "origin": "API_DEFINITION", + "regionTag": "fleetengine_v1_generated_DeliveryService_DeleteTask_sync", + "segments": [ + { + "end": 49, + "start": 27, + "type": "FULL" + }, + { + "end": 49, + "start": 27, + "type": "SHORT" + }, + { + "end": 40, + "start": 38, + "type": "CLIENT_INITIALIZATION" + }, + { + "end": 45, + "start": 41, + "type": "REQUEST_INITIALIZATION" + }, + { + "start": 46, + "type": "REQUEST_EXECUTION" + }, + { + "end": 50, + "type": "RESPONSE_HANDLING" + } + ], + "title": "fleetengine_v1_generated_delivery_service_delete_task_sync.py" + }, { "canonical": true, "clientMethod": { diff --git a/packages/google-maps-fleetengine-delivery/scripts/fixup_fleetengine_delivery_v1_keywords.py b/packages/google-maps-fleetengine-delivery/scripts/fixup_fleetengine_delivery_v1_keywords.py index 8dc89e72edee..c3fd08316bc9 100644 --- a/packages/google-maps-fleetengine-delivery/scripts/fixup_fleetengine_delivery_v1_keywords.py +++ b/packages/google-maps-fleetengine-delivery/scripts/fixup_fleetengine_delivery_v1_keywords.py @@ -42,6 +42,8 @@ class fleetengine_deliveryCallTransformer(cst.CSTTransformer): 'batch_create_tasks': ('parent', 'requests', 'header', ), 'create_delivery_vehicle': ('parent', 'delivery_vehicle_id', 'delivery_vehicle', 'header', ), 'create_task': ('parent', 'task_id', 'task', 'header', ), + 'delete_delivery_vehicle': ('name', 'header', ), + 'delete_task': ('name', 'header', ), 'get_delivery_vehicle': ('name', 'header', ), 'get_task': ('name', 'header', ), 'get_task_tracking_info': ('name', 'header', ), diff --git a/packages/google-maps-fleetengine-delivery/tests/unit/gapic/fleetengine_delivery_v1/test_delivery_service.py b/packages/google-maps-fleetengine-delivery/tests/unit/gapic/fleetengine_delivery_v1/test_delivery_service.py index c739d003b5ec..34b124307880 100644 --- a/packages/google-maps-fleetengine-delivery/tests/unit/gapic/fleetengine_delivery_v1/test_delivery_service.py +++ b/packages/google-maps-fleetengine-delivery/tests/unit/gapic/fleetengine_delivery_v1/test_delivery_service.py @@ -1755,6 +1755,274 @@ async def test_get_delivery_vehicle_flattened_error_async(): ) +@pytest.mark.parametrize( + "request_type", + [ + delivery_api.DeleteDeliveryVehicleRequest, + dict, + ], +) +def test_delete_delivery_vehicle(request_type, transport: str = "grpc"): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + response = client.delete_delivery_vehicle(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = delivery_api.DeleteDeliveryVehicleRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +def test_delete_delivery_vehicle_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = delivery_api.DeleteDeliveryVehicleRequest( + name="name_value", + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.delete_delivery_vehicle(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == delivery_api.DeleteDeliveryVehicleRequest( + name="name_value", + ) + + +def test_delete_delivery_vehicle_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.delete_delivery_vehicle + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.delete_delivery_vehicle + ] = mock_rpc + request = {} + client.delete_delivery_vehicle(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_delivery_vehicle(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_delivery_vehicle_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.delete_delivery_vehicle + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.delete_delivery_vehicle + ] = mock_rpc + + request = {} + await client.delete_delivery_vehicle(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.delete_delivery_vehicle(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_delivery_vehicle_async( + transport: str = "grpc_asyncio", + request_type=delivery_api.DeleteDeliveryVehicleRequest, +): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_delivery_vehicle(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = delivery_api.DeleteDeliveryVehicleRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.asyncio +async def test_delete_delivery_vehicle_async_from_dict(): + await test_delete_delivery_vehicle_async(request_type=dict) + + +def test_delete_delivery_vehicle_flattened(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.delete_delivery_vehicle( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +def test_delete_delivery_vehicle_flattened_error(): + client = DeliveryServiceClient( + 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.delete_delivery_vehicle( + delivery_api.DeleteDeliveryVehicleRequest(), + name="name_value", + ) + + +@pytest.mark.asyncio +async def test_delete_delivery_vehicle_flattened_async(): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = None + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.delete_delivery_vehicle( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_delete_delivery_vehicle_flattened_error_async(): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.delete_delivery_vehicle( + delivery_api.DeleteDeliveryVehicleRequest(), + name="name_value", + ) + + @pytest.mark.parametrize( "request_type", [ @@ -2842,11 +3110,11 @@ async def test_get_task_flattened_error_async(): @pytest.mark.parametrize( "request_type", [ - delivery_api.UpdateTaskRequest, + delivery_api.DeleteTaskRequest, dict, ], ) -def test_update_task(request_type, transport: str = "grpc"): +def test_delete_task(request_type, transport: str = "grpc"): client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport=transport, @@ -2857,40 +3125,22 @@ def test_update_task(request_type, transport: str = "grpc"): request = request_type() # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.update_task), "__call__") as call: + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: # Designate an appropriate return value for the call. - call.return_value = tasks.Task( - name="name_value", - type_=tasks.Task.Type.PICKUP, - state=tasks.Task.State.OPEN, - task_outcome=tasks.Task.TaskOutcome.SUCCEEDED, - task_outcome_location_source=tasks.Task.TaskOutcomeLocationSource.PROVIDER, - tracking_id="tracking_id_value", - delivery_vehicle_id="delivery_vehicle_id_value", - ) - response = client.update_task(request) + call.return_value = None + response = client.delete_task(request) # Establish that the underlying gRPC stub method was called. assert len(call.mock_calls) == 1 _, args, _ = call.mock_calls[0] - request = delivery_api.UpdateTaskRequest() + request = delivery_api.DeleteTaskRequest() assert args[0] == request # Establish that the response is the type that we expect. - assert isinstance(response, tasks.Task) - assert response.name == "name_value" - assert response.type_ == tasks.Task.Type.PICKUP - assert response.state == tasks.Task.State.OPEN - assert response.task_outcome == tasks.Task.TaskOutcome.SUCCEEDED - assert ( - response.task_outcome_location_source - == tasks.Task.TaskOutcomeLocationSource.PROVIDER - ) - assert response.tracking_id == "tracking_id_value" - assert response.delivery_vehicle_id == "delivery_vehicle_id_value" + assert response is None -def test_update_task_non_empty_request_with_auto_populated_field(): +def test_delete_task_non_empty_request_with_auto_populated_field(): # This test is a coverage failsafe to make sure that UUID4 fields are # automatically populated, according to AIP-4235, with non-empty requests. client = DeliveryServiceClient( @@ -2901,17 +3151,287 @@ def test_update_task_non_empty_request_with_auto_populated_field(): # Populate all string fields in the request which are not UUID4 # since we want to check that UUID4 are populated automatically # if they meet the requirements of AIP 4235. - request = delivery_api.UpdateTaskRequest() + request = delivery_api.DeleteTaskRequest( + name="name_value", + ) # Mock the actual call within the gRPC stub, and fake the request. - with mock.patch.object(type(client.transport.update_task), "__call__") as call: + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: call.return_value.name = ( "foo" # operation_request.operation in compute client(s) expect a string. ) - client.update_task(request=request) + client.delete_task(request=request) call.assert_called() _, args, _ = call.mock_calls[0] - assert args[0] == delivery_api.UpdateTaskRequest() + assert args[0] == delivery_api.DeleteTaskRequest( + name="name_value", + ) + + +def test_delete_task_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.delete_task in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.delete_task] = mock_rpc + request = {} + client.delete_task(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_task(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_task_async_use_cached_wrapped_rpc( + transport: str = "grpc_asyncio", +): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method_async.wrap_method") as wrapper_fn: + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._client._transport.delete_task + in client._client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.AsyncMock() + mock_rpc.return_value = mock.Mock() + client._client._transport._wrapped_methods[ + client._client._transport.delete_task + ] = mock_rpc + + request = {} + await client.delete_task(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + await client.delete_task(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +@pytest.mark.asyncio +async def test_delete_task_async( + transport: str = "grpc_asyncio", request_type=delivery_api.DeleteTaskRequest +): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + response = await client.delete_task(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + request = delivery_api.DeleteTaskRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.asyncio +async def test_delete_task_async_from_dict(): + await test_delete_task_async(request_type=dict) + + +def test_delete_task_flattened(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + client.delete_task( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +def test_delete_task_flattened_error(): + client = DeliveryServiceClient( + 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.delete_task( + delivery_api.DeleteTaskRequest(), + name="name_value", + ) + + +@pytest.mark.asyncio +async def test_delete_task_flattened_async(): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = None + + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + # Call the method with a truthy value for each flattened field, + # using the keyword arguments to the method. + response = await client.delete_task( + name="name_value", + ) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(call.mock_calls) + _, args, _ = call.mock_calls[0] + arg = args[0].name + mock_val = "name_value" + assert arg == mock_val + + +@pytest.mark.asyncio +async def test_delete_task_flattened_error_async(): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + await client.delete_task( + delivery_api.DeleteTaskRequest(), + name="name_value", + ) + + +@pytest.mark.parametrize( + "request_type", + [ + delivery_api.UpdateTaskRequest, + dict, + ], +) +def test_update_task(request_type, transport: str = "grpc"): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Everything is optional in proto3 as far as the runtime is concerned, + # and we are mocking out the actual API, so just send an empty request. + request = request_type() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.update_task), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = tasks.Task( + name="name_value", + type_=tasks.Task.Type.PICKUP, + state=tasks.Task.State.OPEN, + task_outcome=tasks.Task.TaskOutcome.SUCCEEDED, + task_outcome_location_source=tasks.Task.TaskOutcomeLocationSource.PROVIDER, + tracking_id="tracking_id_value", + delivery_vehicle_id="delivery_vehicle_id_value", + ) + response = client.update_task(request) + + # Establish that the underlying gRPC stub method was called. + assert len(call.mock_calls) == 1 + _, args, _ = call.mock_calls[0] + request = delivery_api.UpdateTaskRequest() + assert args[0] == request + + # Establish that the response is the type that we expect. + assert isinstance(response, tasks.Task) + assert response.name == "name_value" + assert response.type_ == tasks.Task.Type.PICKUP + assert response.state == tasks.Task.State.OPEN + assert response.task_outcome == tasks.Task.TaskOutcome.SUCCEEDED + assert ( + response.task_outcome_location_source + == tasks.Task.TaskOutcomeLocationSource.PROVIDER + ) + assert response.tracking_id == "tracking_id_value" + assert response.delivery_vehicle_id == "delivery_vehicle_id_value" + + +def test_update_task_non_empty_request_with_auto_populated_field(): + # This test is a coverage failsafe to make sure that UUID4 fields are + # automatically populated, according to AIP-4235, with non-empty requests. + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Populate all string fields in the request which are not UUID4 + # since we want to check that UUID4 are populated automatically + # if they meet the requirements of AIP 4235. + request = delivery_api.UpdateTaskRequest() + + # Mock the actual call within the gRPC stub, and fake the request. + with mock.patch.object(type(client.transport.update_task), "__call__") as call: + call.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client.update_task(request=request) + call.assert_called() + _, args, _ = call.mock_calls[0] + assert args[0] == delivery_api.UpdateTaskRequest() def test_update_task_use_cached_wrapped_rpc(): @@ -4773,7 +5293,7 @@ def test_get_delivery_vehicle_rest_flattened_error(transport: str = "rest"): ) -def test_update_delivery_vehicle_rest_use_cached_wrapped_rpc(): +def test_delete_delivery_vehicle_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: @@ -4788,7 +5308,7 @@ def test_update_delivery_vehicle_rest_use_cached_wrapped_rpc(): # Ensure method has been cached assert ( - client._transport.update_delivery_vehicle + client._transport.delete_delivery_vehicle in client._transport._wrapped_methods ) @@ -4798,28 +5318,29 @@ def test_update_delivery_vehicle_rest_use_cached_wrapped_rpc(): "foo" # operation_request.operation in compute client(s) expect a string. ) client._transport._wrapped_methods[ - client._transport.update_delivery_vehicle + client._transport.delete_delivery_vehicle ] = mock_rpc request = {} - client.update_delivery_vehicle(request) + client.delete_delivery_vehicle(request) # Establish that the underlying gRPC stub method was called. assert mock_rpc.call_count == 1 - client.update_delivery_vehicle(request) + client.delete_delivery_vehicle(request) # Establish that a new wrapper was not created for this call assert wrapper_fn.call_count == 0 assert mock_rpc.call_count == 2 -def test_update_delivery_vehicle_rest_required_fields( - request_type=delivery_api.UpdateDeliveryVehicleRequest, +def test_delete_delivery_vehicle_rest_required_fields( + request_type=delivery_api.DeleteDeliveryVehicleRequest, ): transport_class = transports.DeliveryServiceRestTransport request_init = {} + request_init["name"] = "" request = request_type(**request_init) pb_request = request_type.pb(request) jsonified_request = json.loads( @@ -4830,24 +5351,23 @@ def test_update_delivery_vehicle_rest_required_fields( unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_delivery_vehicle._get_unset_required_fields(jsonified_request) + ).delete_delivery_vehicle._get_unset_required_fields(jsonified_request) jsonified_request.update(unset_fields) # verify required fields with default values are now present + jsonified_request["name"] = "name_value" + unset_fields = transport_class( credentials=ga_credentials.AnonymousCredentials() - ).update_delivery_vehicle._get_unset_required_fields(jsonified_request) + ).delete_delivery_vehicle._get_unset_required_fields(jsonified_request) # Check that path parameters and body parameters are not mixing in. - assert not set(unset_fields) - set( - ( - "header", - "update_mask", - ) - ) + assert not set(unset_fields) - set(("header",)) jsonified_request.update(unset_fields) # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -4856,7 +5376,7 @@ def test_update_delivery_vehicle_rest_required_fields( request = request_type(**request_init) # Designate an appropriate value for the returned response. - return_value = delivery_vehicles.DeliveryVehicle() + return_value = None # Mock the http request call within the method and fake a response. with mock.patch.object(Session, "request") as req: # We need to mock transcode() because providing default values @@ -4868,10 +5388,189 @@ def test_update_delivery_vehicle_rest_required_fields( pb_request = request_type.pb(request) transcode_result = { "uri": "v1/sample_method", - "method": "patch", + "method": "delete", "query_params": pb_request, } - transcode_result["body"] = pb_request + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_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.delete_delivery_vehicle(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_delivery_vehicle_rest_unset_required_fields(): + transport = transports.DeliveryServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_delivery_vehicle._get_unset_required_fields({}) + assert set(unset_fields) == (set(("header",)) & set(("name",))) + + +def test_delete_delivery_vehicle_rest_flattened(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "providers/sample1/deliveryVehicles/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_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"} + + client.delete_delivery_vehicle(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=providers/*/deliveryVehicles/*}" % client.transport._host, + args[1], + ) + + +def test_delete_delivery_vehicle_rest_flattened_error(transport: str = "rest"): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_delivery_vehicle( + delivery_api.DeleteDeliveryVehicleRequest(), + name="name_value", + ) + + +def test_update_delivery_vehicle_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert ( + client._transport.update_delivery_vehicle + in client._transport._wrapped_methods + ) + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[ + client._transport.update_delivery_vehicle + ] = mock_rpc + + request = {} + client.update_delivery_vehicle(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.update_delivery_vehicle(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_update_delivery_vehicle_rest_required_fields( + request_type=delivery_api.UpdateDeliveryVehicleRequest, +): + transport_class = transports.DeliveryServiceRestTransport + + request_init = {} + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_delivery_vehicle._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).update_delivery_vehicle._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set( + ( + "header", + "update_mask", + ) + ) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = delivery_vehicles.DeliveryVehicle() + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "patch", + "query_params": pb_request, + } + transcode_result["body"] = pb_request transcode.return_value = transcode_result response_value = Response() @@ -5498,6 +6197,177 @@ def test_get_task_rest_flattened_error(transport: str = "rest"): ) +def test_delete_task_rest_use_cached_wrapped_rpc(): + # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, + # instead of constructing them on each call + with mock.patch("google.api_core.gapic_v1.method.wrap_method") as wrapper_fn: + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Should wrap all calls on client creation + assert wrapper_fn.call_count > 0 + wrapper_fn.reset_mock() + + # Ensure method has been cached + assert client._transport.delete_task in client._transport._wrapped_methods + + # Replace cached wrapped function with mock + mock_rpc = mock.Mock() + mock_rpc.return_value.name = ( + "foo" # operation_request.operation in compute client(s) expect a string. + ) + client._transport._wrapped_methods[client._transport.delete_task] = mock_rpc + + request = {} + client.delete_task(request) + + # Establish that the underlying gRPC stub method was called. + assert mock_rpc.call_count == 1 + + client.delete_task(request) + + # Establish that a new wrapper was not created for this call + assert wrapper_fn.call_count == 0 + assert mock_rpc.call_count == 2 + + +def test_delete_task_rest_required_fields(request_type=delivery_api.DeleteTaskRequest): + transport_class = transports.DeliveryServiceRestTransport + + request_init = {} + request_init["name"] = "" + request = request_type(**request_init) + pb_request = request_type.pb(request) + jsonified_request = json.loads( + json_format.MessageToJson(pb_request, use_integers_for_enums=False) + ) + + # verify fields with default values are dropped + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_task._get_unset_required_fields(jsonified_request) + jsonified_request.update(unset_fields) + + # verify required fields with default values are now present + + jsonified_request["name"] = "name_value" + + unset_fields = transport_class( + credentials=ga_credentials.AnonymousCredentials() + ).delete_task._get_unset_required_fields(jsonified_request) + # Check that path parameters and body parameters are not mixing in. + assert not set(unset_fields) - set(("header",)) + jsonified_request.update(unset_fields) + + # verify required fields with non-default values are left alone + assert "name" in jsonified_request + assert jsonified_request["name"] == "name_value" + + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + request = request_type(**request_init) + + # Designate an appropriate value for the returned response. + return_value = None + # Mock the http request call within the method and fake a response. + with mock.patch.object(Session, "request") as req: + # We need to mock transcode() because providing default values + # for required fields will fail the real version if the http_options + # expect actual values for those fields. + with mock.patch.object(path_template, "transcode") as transcode: + # A uri without fields and an empty body will force all the + # request fields to show up in the query_params. + pb_request = request_type.pb(request) + transcode_result = { + "uri": "v1/sample_method", + "method": "delete", + "query_params": pb_request, + } + transcode.return_value = transcode_result + + response_value = Response() + response_value.status_code = 200 + json_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.delete_task(request) + + expected_params = [("$alt", "json;enum-encoding=int")] + actual_params = req.call_args.kwargs["params"] + assert expected_params == actual_params + + +def test_delete_task_rest_unset_required_fields(): + transport = transports.DeliveryServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials + ) + + unset_fields = transport.delete_task._get_unset_required_fields({}) + assert set(unset_fields) == (set(("header",)) & set(("name",))) + + +def test_delete_task_rest_flattened(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # get arguments that satisfy an http rule for this method + sample_request = {"name": "providers/sample1/tasks/sample2"} + + # get truthy value for each flattened field + mock_args = dict( + name="name_value", + ) + mock_args.update(sample_request) + + # Wrap the value into a proper Response obj + response_value = Response() + response_value.status_code = 200 + json_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"} + + client.delete_task(**mock_args) + + # Establish that the underlying call was made with the expected + # request object values. + assert len(req.mock_calls) == 1 + _, args, _ = req.mock_calls[0] + assert path_template.validate( + "%s/v1/{name=providers/*/tasks/*}" % client.transport._host, args[1] + ) + + +def test_delete_task_rest_flattened_error(transport: str = "rest"): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport=transport, + ) + + # Attempting to call a method with both a request object and flattened + # fields is an error. + with pytest.raises(ValueError): + client.delete_task( + delivery_api.DeleteTaskRequest(), + name="name_value", + ) + + def test_update_task_rest_use_cached_wrapped_rpc(): # Clients should use _prep_wrapped_messages to create cached wrapped rpcs, # instead of constructing them on each call @@ -6546,6 +7416,29 @@ def test_get_delivery_vehicle_empty_call_grpc(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_delete_delivery_vehicle_empty_call_grpc(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + call.return_value = None + client.delete_delivery_vehicle(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = delivery_api.DeleteDeliveryVehicleRequest() + + assert args[0] == request_msg + + # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. def test_update_delivery_vehicle_empty_call_grpc(): @@ -6634,6 +7527,27 @@ def test_get_task_empty_call_grpc(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_delete_task_empty_call_grpc(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + call.return_value = None + client.delete_task(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = delivery_api.DeleteTaskRequest() + + assert args[0] == request_msg + + # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. def test_update_task_empty_call_grpc(): @@ -6730,16 +7644,44 @@ def test_create_delivery_vehicle_routing_parameters_request_1_grpc(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.create_delivery_vehicle), "__call__" + type(client.transport.create_delivery_vehicle), "__call__" + ) as call: + call.return_value = delivery_vehicles.DeliveryVehicle() + client.create_delivery_vehicle(request={"parent": "providers/sample1"}) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, kw = call.mock_calls[0] + request_msg = delivery_api.CreateDeliveryVehicleRequest( + **{"parent": "providers/sample1"} + ) + + assert args[0] == request_msg + + expected_headers = {"provider_id": "providers/sample1"} + assert ( + gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"] + ) + + +def test_get_delivery_vehicle_routing_parameters_request_1_grpc(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.get_delivery_vehicle), "__call__" ) as call: call.return_value = delivery_vehicles.DeliveryVehicle() - client.create_delivery_vehicle(request={"parent": "providers/sample1"}) + client.get_delivery_vehicle(request={"name": "providers/sample1"}) # Establish that the underlying stub method was called. call.assert_called() _, args, kw = call.mock_calls[0] - request_msg = delivery_api.CreateDeliveryVehicleRequest( - **{"parent": "providers/sample1"} + request_msg = delivery_api.GetDeliveryVehicleRequest( + **{"name": "providers/sample1"} ) assert args[0] == request_msg @@ -6750,7 +7692,7 @@ def test_create_delivery_vehicle_routing_parameters_request_1_grpc(): ) -def test_get_delivery_vehicle_routing_parameters_request_1_grpc(): +def test_delete_delivery_vehicle_routing_parameters_request_1_grpc(): client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="grpc", @@ -6758,15 +7700,15 @@ def test_get_delivery_vehicle_routing_parameters_request_1_grpc(): # Mock the actual call, and fake the request. with mock.patch.object( - type(client.transport.get_delivery_vehicle), "__call__" + type(client.transport.delete_delivery_vehicle), "__call__" ) as call: - call.return_value = delivery_vehicles.DeliveryVehicle() - client.get_delivery_vehicle(request={"name": "providers/sample1"}) + call.return_value = None + client.delete_delivery_vehicle(request={"name": "providers/sample1"}) # Establish that the underlying stub method was called. call.assert_called() _, args, kw = call.mock_calls[0] - request_msg = delivery_api.GetDeliveryVehicleRequest( + request_msg = delivery_api.DeleteDeliveryVehicleRequest( **{"name": "providers/sample1"} ) @@ -6884,6 +7826,30 @@ def test_get_task_routing_parameters_request_1_grpc(): ) +def test_delete_task_routing_parameters_request_1_grpc(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="grpc", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + call.return_value = None + client.delete_task(request={"name": "providers/sample1"}) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, kw = call.mock_calls[0] + request_msg = delivery_api.DeleteTaskRequest(**{"name": "providers/sample1"}) + + assert args[0] == request_msg + + expected_headers = {"provider_id": "providers/sample1"} + assert ( + gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"] + ) + + def test_update_task_routing_parameters_request_1_grpc(): client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -7068,6 +8034,31 @@ async def test_get_delivery_vehicle_empty_call_grpc_asyncio(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_delete_delivery_vehicle_empty_call_grpc_asyncio(): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_delivery_vehicle(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = delivery_api.DeleteDeliveryVehicleRequest() + + assert args[0] == request_msg + + # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. @pytest.mark.asyncio @@ -7193,6 +8184,29 @@ async def test_get_task_empty_call_grpc_asyncio(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +@pytest.mark.asyncio +async def test_delete_task_empty_call_grpc_asyncio(): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_task(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = delivery_api.DeleteTaskRequest() + + assert args[0] == request_msg + + # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. @pytest.mark.asyncio @@ -7390,6 +8404,36 @@ async def test_get_delivery_vehicle_routing_parameters_request_1_grpc_asyncio(): ) +@pytest.mark.asyncio +async def test_delete_delivery_vehicle_routing_parameters_request_1_grpc_asyncio(): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_delivery_vehicle(request={"name": "providers/sample1"}) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, kw = call.mock_calls[0] + request_msg = delivery_api.DeleteDeliveryVehicleRequest( + **{"name": "providers/sample1"} + ) + + assert args[0] == request_msg + + expected_headers = {"provider_id": "providers/sample1"} + assert ( + gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"] + ) + + @pytest.mark.asyncio async def test_update_delivery_vehicle_routing_parameters_request_1_grpc_asyncio(): client = DeliveryServiceAsyncClient( @@ -7533,6 +8577,32 @@ async def test_get_task_routing_parameters_request_1_grpc_asyncio(): ) +@pytest.mark.asyncio +async def test_delete_task_routing_parameters_request_1_grpc_asyncio(): + client = DeliveryServiceAsyncClient( + credentials=async_anonymous_credentials(), + transport="grpc_asyncio", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + # Designate an appropriate return value for the call. + call.return_value = grpc_helpers_async.FakeUnaryUnaryCall(None) + await client.delete_task(request={"name": "providers/sample1"}) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, kw = call.mock_calls[0] + request_msg = delivery_api.DeleteTaskRequest(**{"name": "providers/sample1"}) + + assert args[0] == request_msg + + expected_headers = {"provider_id": "providers/sample1"} + assert ( + gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"] + ) + + @pytest.mark.asyncio async def test_update_task_routing_parameters_request_1_grpc_asyncio(): client = DeliveryServiceAsyncClient( @@ -7844,18 +8914,156 @@ def get_message_fields(field): } ) - # Remove fields from the sample request which are not present in the runtime version of the dependency - # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime - for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER - field = subfield_to_delete.get("field") - field_repeated = subfield_to_delete.get("is_repeated") - subfield = subfield_to_delete.get("subfield") - if subfield: - if field_repeated: - for i in range(0, len(request_init["delivery_vehicle"][field])): - del request_init["delivery_vehicle"][field][i][subfield] - else: - del request_init["delivery_vehicle"][field][subfield] + # Remove fields from the sample request which are not present in the runtime version of the dependency + # Add `# pragma: NO COVER` because this test code will not run if all subfields are present at runtime + for subfield_to_delete in subfields_not_in_runtime: # pragma: NO COVER + field = subfield_to_delete.get("field") + field_repeated = subfield_to_delete.get("is_repeated") + subfield = subfield_to_delete.get("subfield") + if subfield: + if field_repeated: + for i in range(0, len(request_init["delivery_vehicle"][field])): + del request_init["delivery_vehicle"][field][i][subfield] + else: + del request_init["delivery_vehicle"][field][subfield] + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = delivery_vehicles.DeliveryVehicle( + name="name_value", + navigation_status=common.DeliveryVehicleNavigationStatus.NO_GUIDANCE, + current_route_segment=b"current_route_segment_blob", + type_=delivery_vehicles.DeliveryVehicle.DeliveryVehicleType.AUTO, + ) + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + + # Convert return value to protobuf type + return_value = delivery_vehicles.DeliveryVehicle.pb(return_value) + 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.create_delivery_vehicle(request) + + # Establish that the response is the type that we expect. + assert isinstance(response, delivery_vehicles.DeliveryVehicle) + assert response.name == "name_value" + assert ( + response.navigation_status == common.DeliveryVehicleNavigationStatus.NO_GUIDANCE + ) + assert response.current_route_segment == b"current_route_segment_blob" + assert response.type_ == delivery_vehicles.DeliveryVehicle.DeliveryVehicleType.AUTO + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_create_delivery_vehicle_rest_interceptors(null_interceptor): + transport = transports.DeliveryServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.DeliveryServiceRestInterceptor(), + ) + client = DeliveryServiceClient(transport=transport) + + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.DeliveryServiceRestInterceptor, "post_create_delivery_vehicle" + ) as post, mock.patch.object( + transports.DeliveryServiceRestInterceptor, + "post_create_delivery_vehicle_with_metadata", + ) as post_with_metadata, mock.patch.object( + transports.DeliveryServiceRestInterceptor, "pre_create_delivery_vehicle" + ) as pre: + pre.assert_not_called() + post.assert_not_called() + post_with_metadata.assert_not_called() + pb_message = delivery_api.CreateDeliveryVehicleRequest.pb( + delivery_api.CreateDeliveryVehicleRequest() + ) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + 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 = delivery_vehicles.DeliveryVehicle.to_json( + delivery_vehicles.DeliveryVehicle() + ) + req.return_value.content = return_value + + request = delivery_api.CreateDeliveryVehicleRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + post.return_value = delivery_vehicles.DeliveryVehicle() + post_with_metadata.return_value = delivery_vehicles.DeliveryVehicle(), metadata + + client.create_delivery_vehicle( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + post.assert_called_once() + post_with_metadata.assert_called_once() + + +def test_get_delivery_vehicle_rest_bad_request( + request_type=delivery_api.GetDeliveryVehicleRequest, +): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "providers/sample1/deliveryVehicles/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + 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.get_delivery_vehicle(request) + + +@pytest.mark.parametrize( + "request_type", + [ + delivery_api.GetDeliveryVehicleRequest, + dict, + ], +) +def test_get_delivery_vehicle_rest_call_success(request_type): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "providers/sample1/deliveryVehicles/sample2"} request = request_type(**request_init) # Mock the http request call within the method and fake a response. @@ -7878,7 +9086,7 @@ def get_message_fields(field): 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.create_delivery_vehicle(request) + response = client.get_delivery_vehicle(request) # Establish that the response is the type that we expect. assert isinstance(response, delivery_vehicles.DeliveryVehicle) @@ -7891,7 +9099,7 @@ def get_message_fields(field): @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_create_delivery_vehicle_rest_interceptors(null_interceptor): +def test_get_delivery_vehicle_rest_interceptors(null_interceptor): transport = transports.DeliveryServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -7905,18 +9113,18 @@ def test_create_delivery_vehicle_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.DeliveryServiceRestInterceptor, "post_create_delivery_vehicle" + transports.DeliveryServiceRestInterceptor, "post_get_delivery_vehicle" ) as post, mock.patch.object( transports.DeliveryServiceRestInterceptor, - "post_create_delivery_vehicle_with_metadata", + "post_get_delivery_vehicle_with_metadata", ) as post_with_metadata, mock.patch.object( - transports.DeliveryServiceRestInterceptor, "pre_create_delivery_vehicle" + transports.DeliveryServiceRestInterceptor, "pre_get_delivery_vehicle" ) as pre: pre.assert_not_called() post.assert_not_called() post_with_metadata.assert_not_called() - pb_message = delivery_api.CreateDeliveryVehicleRequest.pb( - delivery_api.CreateDeliveryVehicleRequest() + pb_message = delivery_api.GetDeliveryVehicleRequest.pb( + delivery_api.GetDeliveryVehicleRequest() ) transcode.return_value = { "method": "post", @@ -7933,7 +9141,7 @@ def test_create_delivery_vehicle_rest_interceptors(null_interceptor): ) req.return_value.content = return_value - request = delivery_api.CreateDeliveryVehicleRequest() + request = delivery_api.GetDeliveryVehicleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), @@ -7942,7 +9150,7 @@ def test_create_delivery_vehicle_rest_interceptors(null_interceptor): post.return_value = delivery_vehicles.DeliveryVehicle() post_with_metadata.return_value = delivery_vehicles.DeliveryVehicle(), metadata - client.create_delivery_vehicle( + client.get_delivery_vehicle( request, metadata=[ ("key", "val"), @@ -7955,8 +9163,8 @@ def test_create_delivery_vehicle_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() -def test_get_delivery_vehicle_rest_bad_request( - request_type=delivery_api.GetDeliveryVehicleRequest, +def test_delete_delivery_vehicle_rest_bad_request( + request_type=delivery_api.DeleteDeliveryVehicleRequest, ): client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -7977,17 +9185,17 @@ def test_get_delivery_vehicle_rest_bad_request( response_value.request = mock.Mock() req.return_value = response_value req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} - client.get_delivery_vehicle(request) + client.delete_delivery_vehicle(request) @pytest.mark.parametrize( "request_type", [ - delivery_api.GetDeliveryVehicleRequest, + delivery_api.DeleteDeliveryVehicleRequest, dict, ], ) -def test_get_delivery_vehicle_rest_call_success(request_type): +def test_delete_delivery_vehicle_rest_call_success(request_type): client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" ) @@ -7999,37 +9207,23 @@ def test_get_delivery_vehicle_rest_call_success(request_type): # Mock the http request call within the method and fake a response. with mock.patch.object(type(client.transport._session), "request") as req: # Designate an appropriate value for the returned response. - return_value = delivery_vehicles.DeliveryVehicle( - name="name_value", - navigation_status=common.DeliveryVehicleNavigationStatus.NO_GUIDANCE, - current_route_segment=b"current_route_segment_blob", - type_=delivery_vehicles.DeliveryVehicle.DeliveryVehicleType.AUTO, - ) + return_value = None # Wrap the value into a proper Response obj response_value = mock.Mock() response_value.status_code = 200 - - # Convert return value to protobuf type - return_value = delivery_vehicles.DeliveryVehicle.pb(return_value) - json_return_value = json_format.MessageToJson(return_value) + json_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.get_delivery_vehicle(request) + response = client.delete_delivery_vehicle(request) # Establish that the response is the type that we expect. - assert isinstance(response, delivery_vehicles.DeliveryVehicle) - assert response.name == "name_value" - assert ( - response.navigation_status == common.DeliveryVehicleNavigationStatus.NO_GUIDANCE - ) - assert response.current_route_segment == b"current_route_segment_blob" - assert response.type_ == delivery_vehicles.DeliveryVehicle.DeliveryVehicleType.AUTO + assert response is None @pytest.mark.parametrize("null_interceptor", [True, False]) -def test_get_delivery_vehicle_rest_interceptors(null_interceptor): +def test_delete_delivery_vehicle_rest_interceptors(null_interceptor): transport = transports.DeliveryServiceRestTransport( credentials=ga_credentials.AnonymousCredentials(), interceptor=None @@ -8043,18 +9237,11 @@ def test_get_delivery_vehicle_rest_interceptors(null_interceptor): ) as req, mock.patch.object( path_template, "transcode" ) as transcode, mock.patch.object( - transports.DeliveryServiceRestInterceptor, "post_get_delivery_vehicle" - ) as post, mock.patch.object( - transports.DeliveryServiceRestInterceptor, - "post_get_delivery_vehicle_with_metadata", - ) as post_with_metadata, mock.patch.object( - transports.DeliveryServiceRestInterceptor, "pre_get_delivery_vehicle" + transports.DeliveryServiceRestInterceptor, "pre_delete_delivery_vehicle" ) as pre: pre.assert_not_called() - post.assert_not_called() - post_with_metadata.assert_not_called() - pb_message = delivery_api.GetDeliveryVehicleRequest.pb( - delivery_api.GetDeliveryVehicleRequest() + pb_message = delivery_api.DeleteDeliveryVehicleRequest.pb( + delivery_api.DeleteDeliveryVehicleRequest() ) transcode.return_value = { "method": "post", @@ -8066,21 +9253,15 @@ def test_get_delivery_vehicle_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 = delivery_vehicles.DeliveryVehicle.to_json( - delivery_vehicles.DeliveryVehicle() - ) - req.return_value.content = return_value - request = delivery_api.GetDeliveryVehicleRequest() + request = delivery_api.DeleteDeliveryVehicleRequest() metadata = [ ("key", "val"), ("cephalopod", "squid"), ] pre.return_value = request, metadata - post.return_value = delivery_vehicles.DeliveryVehicle() - post_with_metadata.return_value = delivery_vehicles.DeliveryVehicle(), metadata - client.get_delivery_vehicle( + client.delete_delivery_vehicle( request, metadata=[ ("key", "val"), @@ -8089,8 +9270,6 @@ def test_get_delivery_vehicle_rest_interceptors(null_interceptor): ) pre.assert_called_once() - post.assert_called_once() - post_with_metadata.assert_called_once() def test_update_delivery_vehicle_rest_bad_request( @@ -8931,6 +10110,111 @@ def test_get_task_rest_interceptors(null_interceptor): post_with_metadata.assert_called_once() +def test_delete_task_rest_bad_request(request_type=delivery_api.DeleteTaskRequest): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + # send a request that will satisfy transcoding + request_init = {"name": "providers/sample1/tasks/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a BadRequest error. + with mock.patch.object(Session, "request") as req, pytest.raises( + core_exceptions.BadRequest + ): + # Wrap the value into a proper Response obj + response_value = mock.Mock() + json_return_value = "" + response_value.json = mock.Mock(return_value={}) + 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.delete_task(request) + + +@pytest.mark.parametrize( + "request_type", + [ + delivery_api.DeleteTaskRequest, + dict, + ], +) +def test_delete_task_rest_call_success(request_type): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), transport="rest" + ) + + # send a request that will satisfy transcoding + request_init = {"name": "providers/sample1/tasks/sample2"} + request = request_type(**request_init) + + # Mock the http request call within the method and fake a response. + with mock.patch.object(type(client.transport._session), "request") as req: + # Designate an appropriate value for the returned response. + return_value = None + + # Wrap the value into a proper Response obj + response_value = mock.Mock() + response_value.status_code = 200 + json_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.delete_task(request) + + # Establish that the response is the type that we expect. + assert response is None + + +@pytest.mark.parametrize("null_interceptor", [True, False]) +def test_delete_task_rest_interceptors(null_interceptor): + transport = transports.DeliveryServiceRestTransport( + credentials=ga_credentials.AnonymousCredentials(), + interceptor=None + if null_interceptor + else transports.DeliveryServiceRestInterceptor(), + ) + client = DeliveryServiceClient(transport=transport) + + with mock.patch.object( + type(client.transport._session), "request" + ) as req, mock.patch.object( + path_template, "transcode" + ) as transcode, mock.patch.object( + transports.DeliveryServiceRestInterceptor, "pre_delete_task" + ) as pre: + pre.assert_not_called() + pb_message = delivery_api.DeleteTaskRequest.pb(delivery_api.DeleteTaskRequest()) + transcode.return_value = { + "method": "post", + "uri": "my_uri", + "body": pb_message, + "query_params": pb_message, + } + + req.return_value = mock.Mock() + req.return_value.status_code = 200 + req.return_value.headers = {"header-1": "value-1", "header-2": "value-2"} + + request = delivery_api.DeleteTaskRequest() + metadata = [ + ("key", "val"), + ("cephalopod", "squid"), + ] + pre.return_value = request, metadata + + client.delete_task( + request, + metadata=[ + ("key", "val"), + ("cephalopod", "squid"), + ], + ) + + pre.assert_called_once() + + def test_update_task_rest_bad_request(request_type=delivery_api.UpdateTaskRequest): client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), transport="rest" @@ -9675,6 +10959,28 @@ def test_get_delivery_vehicle_empty_call_rest(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_delete_delivery_vehicle_empty_call_rest(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + client.delete_delivery_vehicle(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = delivery_api.DeleteDeliveryVehicleRequest() + + assert args[0] == request_msg + + # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. def test_update_delivery_vehicle_empty_call_rest(): @@ -9759,6 +11065,26 @@ def test_get_task_empty_call_rest(): assert args[0] == request_msg +# This test is a coverage failsafe to make sure that totally empty calls, +# i.e. request == None and no flattened fields passed, work. +def test_delete_task_empty_call_rest(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + client.delete_task(request=None) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, _ = call.mock_calls[0] + request_msg = delivery_api.DeleteTaskRequest() + + assert args[0] == request_msg + + # This test is a coverage failsafe to make sure that totally empty calls, # i.e. request == None and no flattened fields passed, work. def test_update_task_empty_call_rest(): @@ -9897,6 +11223,33 @@ def test_get_delivery_vehicle_routing_parameters_request_1_rest(): ) +def test_delete_delivery_vehicle_routing_parameters_request_1_rest(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object( + type(client.transport.delete_delivery_vehicle), "__call__" + ) as call: + client.delete_delivery_vehicle(request={"name": "providers/sample1"}) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, kw = call.mock_calls[0] + request_msg = delivery_api.DeleteDeliveryVehicleRequest( + **{"name": "providers/sample1"} + ) + + assert args[0] == request_msg + + expected_headers = {"provider_id": "providers/sample1"} + assert ( + gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"] + ) + + def test_update_delivery_vehicle_routing_parameters_request_1_rest(): client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -9999,6 +11352,29 @@ def test_get_task_routing_parameters_request_1_rest(): ) +def test_delete_task_routing_parameters_request_1_rest(): + client = DeliveryServiceClient( + credentials=ga_credentials.AnonymousCredentials(), + transport="rest", + ) + + # Mock the actual call, and fake the request. + with mock.patch.object(type(client.transport.delete_task), "__call__") as call: + client.delete_task(request={"name": "providers/sample1"}) + + # Establish that the underlying stub method was called. + call.assert_called() + _, args, kw = call.mock_calls[0] + request_msg = delivery_api.DeleteTaskRequest(**{"name": "providers/sample1"}) + + assert args[0] == request_msg + + expected_headers = {"provider_id": "providers/sample1"} + assert ( + gapic_v1.routing_header.to_grpc_metadata(expected_headers) in kw["metadata"] + ) + + def test_update_task_routing_parameters_request_1_rest(): client = DeliveryServiceClient( credentials=ga_credentials.AnonymousCredentials(), @@ -10136,10 +11512,12 @@ def test_delivery_service_base_transport(): methods = ( "create_delivery_vehicle", "get_delivery_vehicle", + "delete_delivery_vehicle", "update_delivery_vehicle", "batch_create_tasks", "create_task", "get_task", + "delete_task", "update_task", "list_tasks", "get_task_tracking_info", @@ -10408,6 +11786,9 @@ def test_delivery_service_client_transport_session_collision(transport_name): session1 = client1.transport.get_delivery_vehicle._session session2 = client2.transport.get_delivery_vehicle._session assert session1 != session2 + session1 = client1.transport.delete_delivery_vehicle._session + session2 = client2.transport.delete_delivery_vehicle._session + assert session1 != session2 session1 = client1.transport.update_delivery_vehicle._session session2 = client2.transport.update_delivery_vehicle._session assert session1 != session2 @@ -10420,6 +11801,9 @@ def test_delivery_service_client_transport_session_collision(transport_name): session1 = client1.transport.get_task._session session2 = client2.transport.get_task._session assert session1 != session2 + session1 = client1.transport.delete_task._session + session2 = client2.transport.delete_task._session + assert session1 != session2 session1 = client1.transport.update_task._session session2 = client2.transport.update_task._session assert session1 != session2