This PR implements a_RestCall class to mapGoogleAPICallError to an asynchronous rest callable that raisesgoogle.auth.exceptions.TransportError.This wrapping is done via a helper methodrest_helpers_async.wrap_errors.

A new parameterkind is introduced inwrap_method which can be one ofgrpc_asyncio (Default Value) orrest_asyncio to distinguish between the type of callables so that we can apply the appropriate wrapping logic.

The property kind is exposed at the transport levelhere and will be configured when wrapping methods during the transport initializationhere.

As a follow up, a similar logic must be implemented for synchronous rest callables to avoid gRPC specific stack trace within a rest call.

RE: Updated Workflow:

I've removed the proposed_RestCall class after determining that it is not needed to wrap a rest callable and just adds unnecessary logic.

The new proposed workflow is as follows:

• This PR still introduces a new parameterkind inwrap_method to determine the type of a callable i.e.grpc_asyncio orrest_asyncio.
• Ifkind=="rest_asyncio", we skip the call togrpc_helpers_async.wrap_errors which is gRPC specific.

Essentially, this does the trick if we follow a similar pattern for error handling to what we're doing in a sync rest call.

We have been lazily creating and raising aGoogleAPICallError from arequests.Response within our GAPICs using thefrom_http_response methodhere. Therefore, we don't need to add the error handling logic to the callable beforehand (we're currently doing both the things for a sync rest call and should skip wrapping the callable beforehand there too).

This PR only handles the error handling logic for an async REST call. It also introduces a new helper i.e.format_http_response_error to create and raise aGoogleAPICallError for a more generic response since the existingfrom_http_response is specific to handling arequests response.

Alternate approach for the introduced helper:

The proposed implementation offormat_http_response_error takes in payload as an argument so that we don't need to await for it within the call and keep this function synchronous.

Alternatively, we can have an async version offrom_http_response that can be used to createGoogleAPICallError for async rest calls.

Follow Up:

As a follow up, we should skip wrapping sync rest callable withgrpc_helpers.wrap_errors (similar to what we're doing here) to avoid the unnecessary gRPC specific logic within a rest call stracktrace.